

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>Tools for fracture simulations &mdash; quippy 7ea04c5+ documentation</title>
  

  
  
    <link rel="shortcut icon" href="_static/favicon.ico"/>
  
  
  

  
  <script type="text/javascript" src="_static/js/modernizr.min.js"></script>
  
    
      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
        <script type="text/javascript" src="_static/jquery.js"></script>
        <script type="text/javascript" src="_static/underscore.js"></script>
        <script type="text/javascript" src="_static/doctools.js"></script>
        <script type="text/javascript" src="_static/language_data.js"></script>
        <script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"processClass": "math|output_area", "processEscapes": true, "ignoreClass": "document", "inlineMath": [["$", "$"], ["\\(", "\\)"]]}})</script>
    
    <script type="text/javascript" src="_static/js/theme.js"></script>

    

  
  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
  <link rel="stylesheet" href="_static/theme_overrides.css" type="text/css" />
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" /> 
</head>

<body class="wy-body-for-nav">

   
  <div class="wy-grid-for-nav">
    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search" >
          

          
            <a href="index.html" class="icon icon-home"> quippy
          

          
            
            <img src="_static/hybrid.png" class="logo" alt="Logo"/>
          
          </a>

          
            
            
              <div class="version">
                7ea04c5+
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
    
            
            
              
            
            
              <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="intro.html">Introduction to <code class="docutils literal notranslate"><span class="pre">quippy</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="install.html">Installation of QUIP and quippy</a></li>
<li class="toctree-l1"><a class="reference internal" href="Tutorials/index.html">Tutorials</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="quippy.html">Quippy library reference</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="quippy.html#core-functionality">Core functionality</a></li>
<li class="toctree-l2 current"><a class="reference internal" href="quippy.html#structure-generation-manipulation-and-analysis">Structure generation, manipulation and analysis</a><ul class="current">
<li class="toctree-l3"><a class="reference internal" href="structures.html">Structure building routines</a></li>
<li class="toctree-l3"><a class="reference internal" href="descriptors.html">Descriptors for atomic environments</a></li>
<li class="toctree-l3 current"><a class="current reference internal" href="#">Tools for fracture simulations</a><ul class="simple">
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="clusters.html">Cluster carving routines</a></li>
<li class="toctree-l3"><a class="reference internal" href="find_surface_atoms.html">Identification of atoms on surfaces</a></li>
<li class="toctree-l3"><a class="reference internal" href="real_space_covariance.html">Real-space covariance representation of atomic environments</a></li>
<li class="toctree-l3"><a class="reference internal" href="topology.html">Some utilities for topological analysis</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#molecular-dynamics">Molecular Dynamics</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#additional-tools-for-potentials">Additional tools for Potentials</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#mathematical-and-optimisation-tools">Mathematical and optimisation tools</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#units-data-and-constants">Units, Data and Constants</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#low-level-routines-and-datatypes">Low level routines and datatypes</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="visualisation.html">Visualisation Tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="fortran_wrapper.html">Appendix: wrapping Fortran 90 Code</a></li>
<li class="toctree-l1"><a class="reference internal" href="teach_sparse.html">Command line options of the teach_sparse main program</a></li>
</ul>

            
          
    <p></p>
    <ul>
        <li><a href="genindex.html">Index</a></li>
        <li><a href="py-modindex.html">Module Index</a></li>
        <li><a href="search.html">Search Page</a></li>
        <li><a href="_modules/index.html">Module Source Code</a></li>
    </ul>
  
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="index.html">quippy</a>
        
      </nav>


      <div class="wy-nav-content">
        
        <div class="rst-content">
        
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="index.html">Docs</a> &raquo;</li>
        
          <li><a href="quippy.html">Quippy library reference</a> &raquo;</li>
        
      <li>Tools for fracture simulations</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/crack.rst.txt" rel="nofollow"> View page source</a>
          
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  
<style>
/* CSS overrides for sphinx_rtd_theme */

/* 24px margin */
.nbinput.nblast,
.nboutput.nblast {
    margin-bottom: 19px;  /* padding has already 5px */
}

/* ... except between code cells! */
.nblast + .nbinput {
    margin-top: -19px;
}

.admonition > p:before {
    margin-right: 4px;  /* make room for the exclamation icon */
}

/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
    text-align: unset;
}
</style>
<div class="section" id="module-quippy.crack">
<span id="tools-for-fracture-simulations"></span><h1>Tools for fracture simulations<a class="headerlink" href="#module-quippy.crack" title="Permalink to this headline">¶</a></h1>
<p>Module contents for <a class="reference internal" href="#module-quippy.crack" title="quippy.crack: Tools for fracture simulations"><code class="xref py py-mod docutils literal notranslate"><span class="pre">quippy.crack</span></code></a>:</p>
<p class="rubric">Classes</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-obj docutils literal notranslate"><span class="pre">CrackParams</span></code></a>([filename,validate])</td>
<td>This type contains all the parameters for a crack simulation, each of which is described briefly below.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.ConstantStrainRate" title="quippy.crack.ConstantStrainRate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ConstantStrainRate</span></code></a>(orig_height,&nbsp;delta_strain)</td>
<td>Constraint which increments epsilon_yy at a constant strain rate</td>
</tr>
</tbody>
</table>
<p class="rubric">Functions</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_is_edge_atom" title="quippy.crack.crack_is_edge_atom"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_is_edge_atom</span></code></a>(slab,i,edge_gap)</td>
<td>Returns true if atom <code class="docutils literal notranslate"><span class="pre">i</span></code> is near to an open surface of slab.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_parse_name" title="quippy.crack.crack_parse_name"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_parse_name</span></code></a>(crackname)</td>
<td>Parse crack name in the format is (ijk)[lmn], with negative numbers denoted by a trailing <code class="docutils literal notranslate"><span class="pre">b</span></code> (short for <code class="docutils literal notranslate"><span class="pre">bar</span></code>), e.g.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_hybrid_calc_args" title="quippy.crack.crack_hybrid_calc_args"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_hybrid_calc_args</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_g_to_k" title="quippy.crack.crack_g_to_k"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_g_to_k</span></code></a>(g,e,v,[mode])</td>
<td>Convert from energy release rate <span class="math notranslate nohighlight">\(G\)</span> to stress intensity factor <span class="math notranslate nohighlight">\(K\)</span> Units: G (J/m:math:<cite>^2</cite>), E (GPa), K (Pa sqrt(m))</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.percolation_step" title="quippy.crack.percolation_step"><code class="xref py py-obj docutils literal notranslate"><span class="pre">percolation_step</span></code></a>(grid)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_setup_marks" title="quippy.crack.crack_setup_marks"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_setup_marks</span></code></a>(crack_slab,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_update_selection_crack_front" title="quippy.crack.crack_update_selection_crack_front"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_update_selection_crack_front</span></code></a>(at,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_is_topbottom_edge_atom" title="quippy.crack.crack_is_topbottom_edge_atom"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_is_topbottom_edge_atom</span></code></a>(slab,i,edge_gap)</td>
<td>Returns true if atom <code class="docutils literal notranslate"><span class="pre">i</span></code> is the topbottom surface of slab Topbottom surfaces are planes at <span class="math notranslate nohighlight">\(y = \pm\)</span></td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_make_slab" title="quippy.crack.crack_make_slab"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_make_slab</span></code></a>(params,classicalpot)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_apply_strain_ramp" title="quippy.crack.crack_apply_strain_ramp"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_apply_strain_ramp</span></code></a>(at,g1,g2,d1,d2,d3,d4)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_strain_to_g" title="quippy.crack.crack_strain_to_g"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain_to_g</span></code></a>(strain,e,v,height)</td>
<td>Calculate energy release rate <span class="math notranslate nohighlight">\(G\)</span> from strain using :math:<code class="docutils literal notranslate"><span class="pre">G</span> <span class="pre">=</span> <span class="pre">\frac{1}{2}</span> <span class="pre">\frac{E}{1-\nu^2}</span> <span class="pre">\epsilon^2</span> <span class="pre">h:math:</span></code> from thin strip result.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_find_tip_coordination" title="quippy.crack.crack_find_tip_coordination"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_tip_coordination</span></code></a>(…)</td>
<td>Return <span class="math notranslate nohighlight">\(x\)</span> coordinate of rightmost undercoordinated atom</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.in_ellipse" title="quippy.crack.in_ellipse"><code class="xref py py-obj docutils literal notranslate"><span class="pre">in_ellipse</span></code></a>(d,ellipse)</td>
<td>Return true if the point <code class="docutils literal notranslate"><span class="pre">d</span></code> is within an ellipse centred at the origin with the <span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span>, and <span class="math notranslate nohighlight">\(z\)</span> radii specifeid in the vector <code class="docutils literal notranslate"><span class="pre">ellipse</span></code>.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_find_tip_local_energy" title="quippy.crack.crack_find_tip_local_energy"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_tip_local_energy</span></code></a>(at,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_update_selection" title="quippy.crack.crack_update_selection"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_update_selection</span></code></a>(at,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_mm_calc_args" title="quippy.crack.crack_mm_calc_args"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_mm_calc_args</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_check_coordination_boundaries" title="quippy.crack.crack_check_coordination_boundaries"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_coordination_boundaries</span></code></a>(at,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.select_ellipse" title="quippy.crack.select_ellipse"><code class="xref py py-obj docutils literal notranslate"><span class="pre">select_ellipse</span></code></a>(at,ellipse,ellipse_bias,list,c)</td>
<td>Select atoms in ellipse centred on an atom and with given principal radii</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_uniform_load" title="quippy.crack.crack_uniform_load"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_uniform_load</span></code></a>(…)</td>
<td>Rescale atoms in slab, with atoms in front of either crack tip strained in y direction by <code class="docutils literal notranslate"><span class="pre">strain</span></code> and atoms behind crack tip rigidly shifted to keep top and bottom edges flat.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_g_to_strain" title="quippy.crack.crack_g_to_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_g_to_strain</span></code></a>(g,e,v,height)</td>
<td>Calculate <span class="math notranslate nohighlight">\(epsilon\)</span> from <span class="math notranslate nohighlight">\(G\)</span>, inverse of above formula.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_k_to_g" title="quippy.crack.crack_k_to_g"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_k_to_g</span></code></a>(k,e,v,[mode])</td>
<td>Convert from stress intensity factor <span class="math notranslate nohighlight">\(K\)</span> to energy release rate <span class="math notranslate nohighlight">\(G\)</span> Units: G (J/m:math:<cite>^2</cite>), E (GPa), K (Pa sqrt(m))</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_update_connect" title="quippy.crack.crack_update_connect"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_update_connect</span></code></a>(at,params)</td>
<td>Use hysteretic version of calc_connect() so we can use relative cutoffs Update the connectivity of a crack slab.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_find_surface_atoms" title="quippy.crack.crack_find_surface_atoms"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_surface_atoms</span></code></a>(at)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_find_tip" title="quippy.crack.crack_find_tip"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_tip</span></code></a>(at,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_calc_load_field" title="quippy.crack.crack_calc_load_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_calc_load_field</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_apply_load_increment" title="quippy.crack.crack_apply_load_increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_apply_load_increment</span></code></a>(at,[g_increment])</td>
<td>Increase the load by adding the the load displacement field to the atomic positions.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_measure_g" title="quippy.crack.crack_measure_g"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_measure_g</span></code></a>(at,e,v,orig_height)</td>
<td>Measure the current height of slab and calculate energy release rate <span class="math notranslate nohighlight">\(G\)</span> from current and original heights and elastic constants <span class="math notranslate nohighlight">\(E\)</span> and <span class="math notranslate nohighlight">\(\nu\)</span>, using the equation :math:`` G = frac{1}{2} frac{E}{1-nu^2} frac{{h - h_0}^2}{h_0} :math:`` where <span class="math notranslate nohighlight">\(h_0\)</span> is the original height and <span class="math notranslate nohighlight">\(h\)</span> the new height.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_k_field" title="quippy.crack.crack_k_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_k_field</span></code></a>(…)</td>
<td>Calculate Irwin K-field stresses and/or displacements for all atoms in <code class="docutils literal notranslate"><span class="pre">at</span></code>.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_find_tip_percolation" title="quippy.crack.crack_find_tip_percolation"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_tip_percolation</span></code></a>(at,params)</td>
<td>Locate crack tips within <code class="docutils literal notranslate"><span class="pre">at</span></code> using a percolation algorithm.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_update_selection_coordination" title="quippy.crack.crack_update_selection_coordination"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_update_selection_coordination</span></code></a>(at,params)</td>
<td>Update QM selection region for a crack configuration using the <code class="docutils literal notranslate"><span class="pre">nn</span></code> and <code class="docutils literal notranslate"><span class="pre">changed_nn</span></code> properties and the <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> parameter from the atoms structure, as well as the selection parameters in <code class="docutils literal notranslate"><span class="pre">params</span></code>.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_make_seed" title="quippy.crack.crack_make_seed"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_make_seed</span></code></a>(crack_slab,params)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_check_coordination" title="quippy.crack.crack_check_coordination"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_coordination</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_print" title="quippy.crack.crack_print"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_print</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Print crack slab to XYZ file, using properties defined in ‘params%io_print_properties’ or all properties if ‘params%io_print_all_properties’ is true.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_strain_energy_release_rate" title="quippy.crack.crack_strain_energy_release_rate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain_energy_release_rate</span></code></a>(at[,&nbsp;bulk,&nbsp;…])</td>
<td>Compute strain energy release rate G from elastic potential energy in a strip</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.crack_strain" title="quippy.crack.crack_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain</span></code></a>(at)</td>
<td>Returns strain of crack specimen</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.crack_find_griffith_load" title="quippy.crack.crack_find_griffith_load"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_find_griffith_load</span></code></a>(a,&nbsp;b,&nbsp;pot[,&nbsp;relax])</td>
<td>Given two configurations (a, b) which differ by one broken bond, find the Griffith load, that is the load at which <cite>a</cite> and <cite>b</cite> have the same energy accorinding to the model potential <cite>pot</cite>.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.stress_intensity_factor" title="quippy.crack.stress_intensity_factor"><code class="xref py py-obj docutils literal notranslate"><span class="pre">stress_intensity_factor</span></code></a>(at)</td>
<td>Returns stress instensity factor for mode I loading (K_I) in MPa sqrt(m)</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.make_crack_advance_map" title="quippy.crack.make_crack_advance_map"><code class="xref py py-obj docutils literal notranslate"><span class="pre">make_crack_advance_map</span></code></a>(atoms[,&nbsp;tol])</td>
<td>Find mapping from atom indices to the index of atom one step ahead of them in the crack propagation direction (i.e.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.find_crack_tip_coordination" title="quippy.crack.find_crack_tip_coordination"><code class="xref py py-obj docutils literal notranslate"><span class="pre">find_crack_tip_coordination</span></code></a>(atoms[,&nbsp;…])</td>
<td>Return position of crack tip in <cite>atoms</cite>, based on atomic coordination.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.irwin_modeI_crack_tip_stress_field" title="quippy.crack.irwin_modeI_crack_tip_stress_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">irwin_modeI_crack_tip_stress_field</span></code></a>(K,&nbsp;r,&nbsp;t)</td>
<td>Compute Irwin singular crack tip stress field</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.strain_to_G" title="quippy.crack.strain_to_G"><code class="xref py py-obj docutils literal notranslate"><span class="pre">strain_to_G</span></code></a>(strain,&nbsp;E,&nbsp;nu,&nbsp;orig_height)</td>
<td>Convert from strain to energy release rate G for thin strip geometry</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.G_to_strain" title="quippy.crack.G_to_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">G_to_strain</span></code></a>(G,&nbsp;E,&nbsp;nu,&nbsp;orig_height)</td>
<td>Convert from energy release rate G to strain for thin strip geometry</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.get_strain" title="quippy.crack.get_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_strain</span></code></a>(atoms)</td>
<td>Return the current strain on thin strip configuration <cite>atoms</cite></td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.get_energy_release_rate" title="quippy.crack.get_energy_release_rate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_energy_release_rate</span></code></a>(atoms)</td>
<td>Return the current energy release rate G for <a href="#id1"><span class="problematic" id="id2">`</span></a>atoms</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.get_stress_intensity_factor" title="quippy.crack.get_stress_intensity_factor"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_stress_intensity_factor</span></code></a>(atoms)</td>
<td>Return stress intensity factor K_I</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.fit_crack_stress_field" title="quippy.crack.fit_crack_stress_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_crack_stress_field</span></code></a>(atoms[,&nbsp;r_range,&nbsp;…])</td>
<td>Perform a least squares fit of near-tip stress field to Irwin solution</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.find_crack_tip_stress_field" title="quippy.crack.find_crack_tip_stress_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">find_crack_tip_stress_field</span></code></a>(atoms[,&nbsp;…])</td>
<td>Find the position of the crack tip by fitting to the Irwin <cite>K</cite>-field solution</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.plot_stress_fields" title="quippy.crack.plot_stress_fields"><code class="xref py py-obj docutils literal notranslate"><span class="pre">plot_stress_fields</span></code></a>(atoms[,&nbsp;r_range,&nbsp;…])</td>
<td>Fit and plot atomistic and continuum stress fields</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.thin_strip_displacement_y" title="quippy.crack.thin_strip_displacement_y"><code class="xref py py-obj docutils literal notranslate"><span class="pre">thin_strip_displacement_y</span></code></a>(x,&nbsp;y,&nbsp;strain,&nbsp;a,&nbsp;b)</td>
<td>Return vertical displacement ramp used to apply initial strain to slab</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.print_crack_system" title="quippy.crack.print_crack_system"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_crack_system</span></code></a>(crack_direction,&nbsp;…)</td>
<td>Pretty printing of crack crystallographic coordinate system</td>
</tr>
</tbody>
</table>
<p class="rubric">Attributes</p>
<table border="1" class="docutils">
<colgroup>
<col width="81%" />
<col width="19%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Value</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">MAX_PROPERTIES</span></code></td>
<td>100</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">MAX_MD_STANZA</span></code></td>
<td>5</td>
</tr>
</tbody>
</table>
<dl class="class">
<dt id="quippy.crack.CrackParams">
<em class="property">class </em><code class="descclassname">quippy.crack.</code><code class="descname">CrackParams</code><span class="sig-paren">(</span><span class="optional">[</span><em>filename</em>, <em>validate</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.CrackParams" title="Permalink to this definition">¶</a></dt>
<dd><p>This type contains all the parameters for a crack simulation, each of which is described briefly
below.</p>
<p>Initialise this CrackParams structure and set default
values for all parameters. WARNING: many of these defaults are
only really appropriate for diamond structure silicon fracture.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>filename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>validate</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">__init__initialise</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.
Class is wrapper around Fortran type <code class="docutils literal notranslate"><span class="pre">CrackParams</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Attributes:</th><td class="field-body"><dl class="first last docutils">
<dt><a class="reference internal" href="#quippy.crack.CrackParams.classical_args" title="quippy.crack.CrackParams.classical_args"><code class="xref py py-obj docutils literal notranslate"><span class="pre">classical_args</span></code></a></dt>
<dd><p class="first last">Arguments used to initialise classical potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.classical_args_str" title="quippy.crack.CrackParams.classical_args_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">classical_args_str</span></code></a></dt>
<dd><p class="first last">Arguments used by Calc Potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.classical_force_reweight" title="quippy.crack.CrackParams.classical_force_reweight"><code class="xref py py-obj docutils literal notranslate"><span class="pre">classical_force_reweight</span></code></a></dt>
<dd><p class="first last">Factor by which to reduce classical forces in the embed region.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_align_y" title="quippy.crack.CrackParams.crack_align_y"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_align_y</span></code></a></dt>
<dd><p class="first last">Vertical alignment turned on</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_apply_initial_load" title="quippy.crack.CrackParams.crack_apply_initial_load"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_apply_initial_load</span></code></a></dt>
<dd><p class="first last">If <code class="docutils literal notranslate"><span class="pre">true</span></code>, apply initial loading field to crack slab</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_bulk_filename" title="quippy.crack.CrackParams.crack_bulk_filename"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_bulk_filename</span></code></a></dt>
<dd><p class="first last">Input file containing primitive cell</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_check_coordination_atom_type" title="quippy.crack.CrackParams.crack_check_coordination_atom_type"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_coordination_atom_type</span></code></a></dt>
<dd><p class="first last">Atom type we check the coordination for</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_check_coordination_critical_nneigh" title="quippy.crack.CrackParams.crack_check_coordination_critical_nneigh"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_coordination_critical_nneigh</span></code></a></dt>
<dd><p class="first last">Critical number of neighbours in the connectivity checking</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_check_coordination_region" title="quippy.crack.CrackParams.crack_check_coordination_region"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_coordination_region</span></code></a></dt>
<dd><p class="first last">Region (+/- around y=0 level) where the atomic coordination is checked.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_check_surface_coordination" title="quippy.crack.CrackParams.crack_check_surface_coordination"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_check_surface_coordination</span></code></a></dt>
<dd><p class="first last">Checking of the surface coordination before generating the crack seed</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_curvature" title="quippy.crack.CrackParams.crack_curvature"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_curvature</span></code></a></dt>
<dd><p class="first last">Curvature used when crack_curved_front=T</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_curved_front" title="quippy.crack.CrackParams.crack_curved_front"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_curved_front</span></code></a></dt>
<dd><p class="first last">If true, initialise slab with a curved crack front</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_dislo_seed" title="quippy.crack.CrackParams.crack_dislo_seed"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_dislo_seed</span></code></a></dt>
<dd><p class="first last">atom at the core of the dislocation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_double_ended" title="quippy.crack.CrackParams.crack_double_ended"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_double_ended</span></code></a></dt>
<dd><p class="first last">If true, we do a double ended crack with periodic boundary conditions along <span class="math notranslate nohighlight">\(x\)</span> direction.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_edge_fix_tol" title="quippy.crack.CrackParams.crack_edge_fix_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_edge_fix_tol</span></code></a></dt>
<dd><p class="first last">How close must an atom be to top or bottom to be fixed.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_element" title="quippy.crack.CrackParams.crack_element"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_element</span></code></a></dt>
<dd><p class="first last">Element to make slab from.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_fix_dipoles" title="quippy.crack.CrackParams.crack_fix_dipoles"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_fix_dipoles</span></code></a></dt>
<dd><p class="first last">If true, we keep fixed dipoles for atoms at the edges.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_fix_dipoles_tol" title="quippy.crack.CrackParams.crack_fix_dipoles_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_fix_dipoles_tol</span></code></a></dt>
<dd><p class="first last">How close must an atom be to top or bottom to keep fixed its dipole.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_fix_sides" title="quippy.crack.CrackParams.crack_fix_sides"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_fix_sides</span></code></a></dt>
<dd><p class="first last">If true fix atoms close to left and right edges of slab</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_free_surfaces" title="quippy.crack.CrackParams.crack_free_surfaces"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_free_surfaces</span></code></a></dt>
<dd><p class="first last">If true, crack is 3D with free surfaces at z= +/- depth/2</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_front_alpha" title="quippy.crack.CrackParams.crack_front_alpha"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_front_alpha</span></code></a></dt>
<dd><p class="first last">Value of alpha to use when tip_method=alpha_shape</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_front_angle_threshold" title="quippy.crack.CrackParams.crack_front_angle_threshold"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_front_angle_threshold</span></code></a></dt>
<dd><p class="first last">Maximum bearing for segments to be included in crack front</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_front_window_size" title="quippy.crack.CrackParams.crack_front_window_size"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_front_window_size</span></code></a></dt>
<dd><p class="first last">Size of windows along crack front.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_g" title="quippy.crack.CrackParams.crack_g"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_g</span></code></a></dt>
<dd><p class="first last">Initial energy release rate loading in J/m:math:<cite>^2</cite> (override strain)</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_g_increment" title="quippy.crack.CrackParams.crack_g_increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_g_increment</span></code></a></dt>
<dd><p class="first last">Rate of loading, expressed as increment in G (override strain_increment)</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_graphene_notch_height" title="quippy.crack.CrackParams.crack_graphene_notch_height"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_graphene_notch_height</span></code></a></dt>
<dd><p class="first last">Height of graphene notch.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_graphene_notch_width" title="quippy.crack.CrackParams.crack_graphene_notch_width"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_graphene_notch_width</span></code></a></dt>
<dd><p class="first last">Width of graphene notch.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_graphene_theta" title="quippy.crack.CrackParams.crack_graphene_theta"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_graphene_theta</span></code></a></dt>
<dd><p class="first last">Rotation angle of graphene plane, in radians.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_height" title="quippy.crack.CrackParams.crack_height"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_height</span></code></a></dt>
<dd><p class="first last">Height of crack slab, in AA{}.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_initial_velocity_field" title="quippy.crack.CrackParams.crack_initial_velocity_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_initial_velocity_field</span></code></a></dt>
<dd><p class="first last">If true, initialise velocity field with dU/dc</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_lattice_guess" title="quippy.crack.CrackParams.crack_lattice_guess"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_lattice_guess</span></code></a></dt>
<dd><p class="first last">Guess at bulk lattice parameter, used to obtain accurate result.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_load_interp_length" title="quippy.crack.CrackParams.crack_load_interp_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_load_interp_length</span></code></a></dt>
<dd><p class="first last">Length over which linear interpolation between k-field</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_loading" title="quippy.crack.CrackParams.crack_loading"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_loading</span></code></a></dt>
<dd><p class="first last"><code class="docutils literal notranslate"><span class="pre">uniform</span></code> for constant load,</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_name" title="quippy.crack.CrackParams.crack_name"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_name</span></code></a></dt>
<dd><p class="first last">Crack name, in format <code class="docutils literal notranslate"><span class="pre">(abc)[def]</span></code> with negative indices denoted by a trailing <code class="docutils literal notranslate"><span class="pre">b</span></code> (for bar), e.g.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_num_layers" title="quippy.crack.CrackParams.crack_num_layers"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_num_layers</span></code></a></dt>
<dd><p class="first last">Number of primitive cells in <span class="math notranslate nohighlight">\(z\)</span> direction</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_ramp_end_g" title="quippy.crack.CrackParams.crack_ramp_end_g"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_ramp_end_g</span></code></a></dt>
<dd><p class="first last">Loading at end of ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_ramp_length" title="quippy.crack.CrackParams.crack_ramp_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_ramp_length</span></code></a></dt>
<dd><p class="first last">Length of ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_ramp_start_length" title="quippy.crack.CrackParams.crack_ramp_start_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_ramp_start_length</span></code></a></dt>
<dd><p class="first last">Length of the region in between the crack tip and the start of the ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_relax_bulk" title="quippy.crack.CrackParams.crack_relax_bulk"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_relax_bulk</span></code></a></dt>
<dd><p class="first last">If true (default) relax bulk cell using classical potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_relax_loading_field" title="quippy.crack.CrackParams.crack_relax_loading_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_relax_loading_field</span></code></a></dt>
<dd><p class="first last">Should <code class="docutils literal notranslate"><span class="pre">makecrack</span></code> relax the applied loading field</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_rescale_x" title="quippy.crack.CrackParams.crack_rescale_x"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_rescale_x</span></code></a></dt>
<dd><p class="first last">Rescale atomsatoms  in x direction by v</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_rescale_x_z" title="quippy.crack.CrackParams.crack_rescale_x_z"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_rescale_x_z</span></code></a></dt>
<dd><p class="first last">Rescale atomsatoms  in x direction by v and in z direction by v2</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_seed_embed_tol" title="quippy.crack.CrackParams.crack_seed_embed_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_seed_embed_tol</span></code></a></dt>
<dd><p class="first last">Atoms closer than this distance from crack tip will be used to seed embed region.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_seed_length" title="quippy.crack.CrackParams.crack_seed_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_seed_length</span></code></a></dt>
<dd><p class="first last">Length of seed crack.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_slab_filename" title="quippy.crack.CrackParams.crack_slab_filename"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_slab_filename</span></code></a></dt>
<dd><p class="first last">Input file to use instead of generating slabs.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.crack_strain" title="quippy.crack.crack_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain</span></code></a></dt>
<dd><p class="first last">Initial applied strain</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_strain_increment" title="quippy.crack.CrackParams.crack_strain_increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain_increment</span></code></a></dt>
<dd><p class="first last">Rate of loading, expressed as strain of initial loading</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_strain_zone_width" title="quippy.crack.CrackParams.crack_strain_zone_width"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_strain_zone_width</span></code></a></dt>
<dd><p class="first last">Distance over which strain increases.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_structure" title="quippy.crack.CrackParams.crack_structure"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_structure</span></code></a></dt>
<dd><p class="first last">Structure: so far <code class="docutils literal notranslate"><span class="pre">diamond</span></code> and <code class="docutils literal notranslate"><span class="pre">graphene</span></code> are supported</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_thermostat_ramp_length" title="quippy.crack.CrackParams.crack_thermostat_ramp_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_thermostat_ramp_length</span></code></a></dt>
<dd><p class="first last">Length of thermostat ramp used for stadium damping at left and right edges</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_thermostat_ramp_max_tau" title="quippy.crack.CrackParams.crack_thermostat_ramp_max_tau"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_thermostat_ramp_max_tau</span></code></a></dt>
<dd><p class="first last">Value of thermostat tau at end of ramp, in fs.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_tip_grid_size" title="quippy.crack.CrackParams.crack_tip_grid_size"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_tip_grid_size</span></code></a></dt>
<dd><p class="first last">Size (in A) of grid used for locating crack tips</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_tip_method" title="quippy.crack.CrackParams.crack_tip_method"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_tip_method</span></code></a></dt>
<dd><p class="first last">One of <code class="docutils literal notranslate"><span class="pre">coordination</span></code>, <code class="docutils literal notranslate"><span class="pre">percolation</span></code>, <code class="docutils literal notranslate"><span class="pre">local_energy</span></code> or <code class="docutils literal notranslate"><span class="pre">alpha_shape</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_tip_min_separation" title="quippy.crack.CrackParams.crack_tip_min_separation"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_tip_min_separation</span></code></a></dt>
<dd><p class="first last">Minimum seperation (in A) between a pair of crack tips for them to be considered distinct</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_vacuum_size" title="quippy.crack.CrackParams.crack_vacuum_size"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_vacuum_size</span></code></a></dt>
<dd><p class="first last">Amount of vacuum around crack slab.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_width" title="quippy.crack.CrackParams.crack_width"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_width</span></code></a></dt>
<dd><p class="first last">Width of crack slab, in AA{}.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_x_shift" title="quippy.crack.CrackParams.crack_x_shift"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_x_shift</span></code></a></dt>
<dd><p class="first last">Shift required to get “nice” surface terminations on vertical edges</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_y_shift" title="quippy.crack.CrackParams.crack_y_shift"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_y_shift</span></code></a></dt>
<dd><p class="first last">Shift required to align y=0 with centre of a vertical bond.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.crack_z" title="quippy.crack.CrackParams.crack_z"><code class="xref py py-obj docutils literal notranslate"><span class="pre">crack_z</span></code></a></dt>
<dd><p class="first last">Initialised automatically from crack element</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.fit_hops" title="quippy.crack.CrackParams.fit_hops"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_hops</span></code></a></dt>
<dd><p class="first last">Number of hops used to generate fit region from embed region</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.fit_method" title="quippy.crack.CrackParams.fit_method"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_method</span></code></a></dt>
<dd><p class="first last">Method to use for force mixing: should be one of</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.fit_spring_hops" title="quippy.crack.CrackParams.fit_spring_hops"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_spring_hops</span></code></a></dt>
<dd><p class="first last">Number of hops used when creating list of springs</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.force_integration_end_file" title="quippy.crack.CrackParams.force_integration_end_file"><code class="xref py py-obj docutils literal notranslate"><span class="pre">force_integration_end_file</span></code></a></dt>
<dd><p class="first last">XYZ file containing ending configuration for force integration.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.force_integration_n_steps" title="quippy.crack.CrackParams.force_integration_n_steps"><code class="xref py py-obj docutils literal notranslate"><span class="pre">force_integration_n_steps</span></code></a></dt>
<dd><p class="first last">Number of steps to take in force integration</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.hack_fit_on_eqm_coordination_only" title="quippy.crack.CrackParams.hack_fit_on_eqm_coordination_only"><code class="xref py py-obj docutils literal notranslate"><span class="pre">hack_fit_on_eqm_coordination_only</span></code></a></dt>
<dd><p class="first last">Only include fit atoms that have coordination number equal to <code class="docutils literal notranslate"><span class="pre">md_eqm_coordination</span></code> (used for graphene).</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.hack_qm_zero_z_force" title="quippy.crack.CrackParams.hack_qm_zero_z_force"><code class="xref py py-obj docutils literal notranslate"><span class="pre">hack_qm_zero_z_force</span></code></a></dt>
<dd><p class="first last">Zero <span class="math notranslate nohighlight">\(z\)</span> component of all forces (used for graphene)</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_backup" title="quippy.crack.CrackParams.io_backup"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_backup</span></code></a></dt>
<dd><p class="first last">If true, create backups of check files</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_checkpoint_interval" title="quippy.crack.CrackParams.io_checkpoint_interval"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_checkpoint_interval</span></code></a></dt>
<dd><p class="first last">Interval between writing checkpoint files, in fs.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_checkpoint_path" title="quippy.crack.CrackParams.io_checkpoint_path"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_checkpoint_path</span></code></a></dt>
<dd><p class="first last">Path to write checkpoint files to.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_mpi_print_all" title="quippy.crack.CrackParams.io_mpi_print_all"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_mpi_print_all</span></code></a></dt>
<dd><p class="first last">Print output on all nodes.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_netcdf" title="quippy.crack.CrackParams.io_netcdf"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_netcdf</span></code></a></dt>
<dd><p class="first last">If true, output in NetCDF format instead of XYZ</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_print_all_properties" title="quippy.crack.CrackParams.io_print_all_properties"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_print_all_properties</span></code></a></dt>
<dd><p class="first last">If true, print all atom properties to movie file.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_print_interval" title="quippy.crack.CrackParams.io_print_interval"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_print_interval</span></code></a></dt>
<dd><p class="first last">Interval between movie XYZ frames, in fs.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_print_properties" title="quippy.crack.CrackParams.io_print_properties"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_print_properties</span></code></a></dt>
<dd><p class="first last">List of properties to print to movie file.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_timing" title="quippy.crack.CrackParams.io_timing"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_timing</span></code></a></dt>
<dd><p class="first last">If true, enable timing (default false)</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.io_verbosity" title="quippy.crack.CrackParams.io_verbosity"><code class="xref py py-obj docutils literal notranslate"><span class="pre">io_verbosity</span></code></a></dt>
<dd><p class="first last">Output verbosity.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_eps_guess" title="quippy.crack.CrackParams.minim_eps_guess"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_eps_guess</span></code></a></dt>
<dd><p class="first last">Initial guess for line search step size <span class="math notranslate nohighlight">\(\epsilon\)</span>.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_fire_dt0" title="quippy.crack.CrackParams.minim_fire_dt0"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_fire_dt0</span></code></a></dt>
<dd><p class="first last">If using fire_minim, the initial step size</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_fire_dt_max" title="quippy.crack.CrackParams.minim_fire_dt_max"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_fire_dt_max</span></code></a></dt>
<dd><p class="first last">If using fire_minim, the maximum step size</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_linminroutine" title="quippy.crack.CrackParams.minim_linminroutine"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_linminroutine</span></code></a></dt>
<dd><p class="first last">Linmin routine, e.g.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_max_steps" title="quippy.crack.CrackParams.minim_max_steps"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_max_steps</span></code></a></dt>
<dd><p class="first last">Maximum number of minimisation steps.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_method" title="quippy.crack.CrackParams.minim_method"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_method</span></code></a></dt>
<dd><p class="first last">Minimisation method: use <code class="docutils literal notranslate"><span class="pre">cg</span></code> for conjugate gradients or <code class="docutils literal notranslate"><span class="pre">sd</span></code> for steepest descent.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_minimise_mm" title="quippy.crack.CrackParams.minim_minimise_mm"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_minimise_mm</span></code></a></dt>
<dd><p class="first last">Should we minimise classical degrees of freedom before each QM force evaluation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_args_str" title="quippy.crack.CrackParams.minim_mm_args_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_args_str</span></code></a></dt>
<dd><p class="first last">Args string to be passed to MM calc() routine</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_eps_guess" title="quippy.crack.CrackParams.minim_mm_eps_guess"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_eps_guess</span></code></a></dt>
<dd><p class="first last">Initial guess for line search <span class="math notranslate nohighlight">\(\epsilon\)</span> for MM minimisation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_linminroutine" title="quippy.crack.CrackParams.minim_mm_linminroutine"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_linminroutine</span></code></a></dt>
<dd><p class="first last">Linmin routine for MM minimisation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_max_steps" title="quippy.crack.CrackParams.minim_mm_max_steps"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_max_steps</span></code></a></dt>
<dd><p class="first last">Maximum number of cg cycles for MM minimisation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_method" title="quippy.crack.CrackParams.minim_mm_method"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_method</span></code></a></dt>
<dd><p class="first last">Minim method for MM minimisation, e.g.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_mm_tol" title="quippy.crack.CrackParams.minim_mm_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_mm_tol</span></code></a></dt>
<dd><p class="first last">Target force tolerance for MM minimisation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_print_output" title="quippy.crack.CrackParams.minim_print_output"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_print_output</span></code></a></dt>
<dd><p class="first last">Number of steps between XYZ confgurations printed</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.minim_tol" title="quippy.crack.CrackParams.minim_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">minim_tol</span></code></a></dt>
<dd><p class="first last">Target force tolerance - geometry optimisation is considered to be</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_args" title="quippy.crack.CrackParams.qm_args"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_args</span></code></a></dt>
<dd><p class="first last">Arguments used to initialise QM potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_args_str" title="quippy.crack.CrackParams.qm_args_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_args_str</span></code></a></dt>
<dd><p class="first last">Arguments used by QM potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_buffer_hops" title="quippy.crack.CrackParams.qm_buffer_hops"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_buffer_hops</span></code></a></dt>
<dd><p class="first last">Number of bond hops used for buffer region</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_calc_force_error" title="quippy.crack.CrackParams.qm_calc_force_error"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_calc_force_error</span></code></a></dt>
<dd><p class="first last">Do a full QM calculation at each stage in extrap and interp to measure force error</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_clusters" title="quippy.crack.CrackParams.qm_clusters"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_clusters</span></code></a></dt>
<dd><p class="first last">Should we carve clusters? Default true.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_cp2k" title="quippy.crack.CrackParams.qm_cp2k"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_cp2k</span></code></a></dt>
<dd><p class="first last">Enable CP2K mode.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_even_electrons" title="quippy.crack.CrackParams.qm_even_electrons"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_even_electrons</span></code></a></dt>
<dd><p class="first last">Discard a hydrogen if necessary to give an overall non-spin-polarised cluster</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_extra_args_str" title="quippy.crack.CrackParams.qm_extra_args_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_extra_args_str</span></code></a></dt>
<dd><p class="first last">Extra arguments passed to ForceMixing potential</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_force_periodic" title="quippy.crack.CrackParams.qm_force_periodic"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_force_periodic</span></code></a></dt>
<dd><p class="first last">Force clusters to be periodic in <span class="math notranslate nohighlight">\(z\)</span> direction.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_buffer" title="quippy.crack.CrackParams.qm_hysteretic_buffer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_buffer</span></code></a></dt>
<dd><p class="first last">If true, manage the buffer region hysteritcally</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_inner_radius" title="quippy.crack.CrackParams.qm_hysteretic_buffer_inner_radius"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_buffer_inner_radius</span></code></a></dt>
<dd><p class="first last">Inner radius used for hystertic buffer region</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_nneighb_only" title="quippy.crack.CrackParams.qm_hysteretic_buffer_nneighb_only"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_buffer_nneighb_only</span></code></a></dt>
<dd><p class="first last">Should hysteretic buffer be formed by nearest neighbor hopping?</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_outer_radius" title="quippy.crack.CrackParams.qm_hysteretic_buffer_outer_radius"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_buffer_outer_radius</span></code></a></dt>
<dd><p class="first last">Outer radius used for hystertic buffer region</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_connect" title="quippy.crack.CrackParams.qm_hysteretic_connect"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_connect</span></code></a></dt>
<dd><p class="first last">Enable hysteretic connectivity</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_connect_cluster_radius" title="quippy.crack.CrackParams.qm_hysteretic_connect_cluster_radius"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_connect_cluster_radius</span></code></a></dt>
<dd><p class="first last">Radius other which to keep track of hysteretic connectivity info.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_connect_inner_factor" title="quippy.crack.CrackParams.qm_hysteretic_connect_inner_factor"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_connect_inner_factor</span></code></a></dt>
<dd><p class="first last">Inner bond factor.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_hysteretic_connect_outer_factor" title="quippy.crack.CrackParams.qm_hysteretic_connect_outer_factor"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_hysteretic_connect_outer_factor</span></code></a></dt>
<dd><p class="first last">Outer bond factor.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_little_clusters" title="quippy.crack.CrackParams.qm_little_clusters"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_little_clusters</span></code></a></dt>
<dd><p class="first last">One big cluster or lots of little ones?</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_randomise_buffer" title="quippy.crack.CrackParams.qm_randomise_buffer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_randomise_buffer</span></code></a></dt>
<dd><p class="first last">Randomise positions of outer layer of buffer atoms slightly to avoid systematic errors.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_rescale_r" title="quippy.crack.CrackParams.qm_rescale_r"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_rescale_r</span></code></a></dt>
<dd><p class="first last">If true, rescale space in QM cluster to match QM lattice constant</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_terminate" title="quippy.crack.CrackParams.qm_terminate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_terminate</span></code></a></dt>
<dd><p class="first last">Terminate clusters with hydrogen atoms</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_transition_hops" title="quippy.crack.CrackParams.qm_transition_hops"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_transition_hops</span></code></a></dt>
<dd><p class="first last">Number of transition hops used for buffer region</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.qm_vacuum_size" title="quippy.crack.CrackParams.qm_vacuum_size"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qm_vacuum_size</span></code></a></dt>
<dd><p class="first last">Amount of vacuum surrounding cluster in non-periodic directions (<span class="math notranslate nohighlight">\(x\)</span> and <span class="math notranslate nohighlight">\(y\)</span> at least).</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.quasi_static_tip_move_tol" title="quippy.crack.CrackParams.quasi_static_tip_move_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">quasi_static_tip_move_tol</span></code></a></dt>
<dd><p class="first last">How far cracktip must advance before we consider fracture to have occurred.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_cutoff_plane" title="quippy.crack.CrackParams.selection_cutoff_plane"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_cutoff_plane</span></code></a></dt>
<dd><p class="first last">Only atoms within this distance from crack tip are candidates for QM selection.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_directionality" title="quippy.crack.CrackParams.selection_directionality"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_directionality</span></code></a></dt>
<dd><p class="first last">Require good directionality of spring space spanning for atoms in embed region.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_edge_tol" title="quippy.crack.CrackParams.selection_edge_tol"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_edge_tol</span></code></a></dt>
<dd><p class="first last">Size of region at edges of crack slab which is ignored for selection purposes.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_ellipse" title="quippy.crack.CrackParams.selection_ellipse"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_ellipse</span></code></a></dt>
<dd><p class="first last">Principal radii of selection ellipse along <span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span> and <span class="math notranslate nohighlight">\(z\)</span> in AA{}.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_ellipse_bias" title="quippy.crack.CrackParams.selection_ellipse_bias"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_ellipse_bias</span></code></a></dt>
<dd><p class="first last">Shift applied to ellipses, expressed as fraction of ellipse radius in <span class="math notranslate nohighlight">\(x\)</span> direction.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_ellipse_buffer" title="quippy.crack.CrackParams.selection_ellipse_buffer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_ellipse_buffer</span></code></a></dt>
<dd><p class="first last">Difference in size between inner and outer selection ellipses, i.e.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_max_qm_atoms" title="quippy.crack.CrackParams.selection_max_qm_atoms"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_max_qm_atoms</span></code></a></dt>
<dd><p class="first last">Maximum number of QM atoms to select</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_method" title="quippy.crack.CrackParams.selection_method"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_method</span></code></a></dt>
<dd><p class="first last">One of <code class="docutils literal notranslate"><span class="pre">static</span></code>, <code class="docutils literal notranslate"><span class="pre">coordination</span></code>, <code class="docutils literal notranslate"><span class="pre">crack_front</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.selection_update_interval" title="quippy.crack.CrackParams.selection_update_interval"><code class="xref py py-obj docutils literal notranslate"><span class="pre">selection_update_interval</span></code></a></dt>
<dd><p class="first last">intervals between QM selection updates, defaults to 0.0_dp meaning <code class="docutils literal notranslate"><span class="pre">every</span> <span class="pre">step</span></code></p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.simulation_classical" title="quippy.crack.CrackParams.simulation_classical"><code class="xref py py-obj docutils literal notranslate"><span class="pre">simulation_classical</span></code></a></dt>
<dd><p class="first last">Perform a purely classical simulation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.simulation_force_initial_load_step" title="quippy.crack.CrackParams.simulation_force_initial_load_step"><code class="xref py py-obj docutils literal notranslate"><span class="pre">simulation_force_initial_load_step</span></code></a></dt>
<dd><p class="first last">Force a load step at beginning of simulation</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.simulation_initial_state" title="quippy.crack.CrackParams.simulation_initial_state"><code class="xref py py-obj docutils literal notranslate"><span class="pre">simulation_initial_state</span></code></a></dt>
<dd><p class="first last">Initial state.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.simulation_seed" title="quippy.crack.CrackParams.simulation_seed"><code class="xref py py-obj docutils literal notranslate"><span class="pre">simulation_seed</span></code></a></dt>
<dd><p class="first last">Random number seed.</p>
</dd>
<dt><a class="reference internal" href="#quippy.crack.CrackParams.simulation_task" title="quippy.crack.CrackParams.simulation_task"><code class="xref py py-obj docutils literal notranslate"><span class="pre">simulation_task</span></code></a></dt>
<dd><p class="first last">Task to perform: <code class="docutils literal notranslate"><span class="pre">md</span></code>, <code class="docutils literal notranslate"><span class="pre">minim</span></code>, etc.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.CrackParams.any_per_atom_tau" title="quippy.crack.CrackParams.any_per_atom_tau"><code class="xref py py-obj docutils literal notranslate"><span class="pre">any_per_atom_tau</span></code></a>(*args,&nbsp;**kwargs)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.crack.CrackParams.print_" title="quippy.crack.CrackParams.print_"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_</span></code></a>([file])</td>
<td>Print out this CrackParams structure</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.CrackParams.read_xml" title="quippy.crack.CrackParams.read_xml"><code class="xref py py-obj docutils literal notranslate"><span class="pre">read_xml</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">read_xml</span></code> containing multiple routines:</td>
</tr>
</tbody>
</table>
<dl class="method">
<dt id="quippy.crack.CrackParams.any_per_atom_tau">
<code class="descname">any_per_atom_tau</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.CrackParams.any_per_atom_tau" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crackparams_any_per_atom_tau</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crackparams_any_per_atom_tau</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.crack.CrackParams.print_">
<code class="descname">print_</code><span class="sig-paren">(</span><span class="optional">[</span><em>file</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.CrackParams.print_" title="Permalink to this definition">¶</a></dt>
<dd><p>Print out this CrackParams structure</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>file</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="system.html#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">print_</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.crack.CrackParams.read_xml">
<code class="descname">read_xml</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.CrackParams.read_xml" title="Permalink to this definition">¶</a></dt>
<dd><p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">read_xml</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">read_xml</code><span class="sig-paren">(</span><em>xmlfile</em><span class="optional">[</span>, <em>validate</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>xmlfile</strong> (<a class="reference internal" href="system.html#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
<li><strong>validate</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crackparams_read_xml</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">read_xml</code><span class="sig-paren">(</span><em>filename</em><span class="optional">[</span>, <em>validate</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><p>Read crack parameters from <code class="docutils literal notranslate"><span class="pre">xmlfile</span></code> into this CrackParams object.
First we reset to default values by calling <code class="docutils literal notranslate"><span class="pre">initialise(this)</span></code>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>filename</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>validate</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crackparams_read_xml_filename</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/crackparams.f95">src/Utils/crackparams.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.classical_args">
<code class="descname">classical_args</code><a class="headerlink" href="#quippy.crack.CrackParams.classical_args" title="Permalink to this definition">¶</a></dt>
<dd><p>Arguments used to initialise classical potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.classical_args_str">
<code class="descname">classical_args_str</code><a class="headerlink" href="#quippy.crack.CrackParams.classical_args_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Arguments used by Calc Potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.classical_force_reweight">
<code class="descname">classical_force_reweight</code><a class="headerlink" href="#quippy.crack.CrackParams.classical_force_reweight" title="Permalink to this definition">¶</a></dt>
<dd><p>Factor by which to reduce classical forces in the embed region. Default is unity.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_align_y">
<code class="descname">crack_align_y</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_align_y" title="Permalink to this definition">¶</a></dt>
<dd><p>Vertical alignment turned on</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_apply_initial_load">
<code class="descname">crack_apply_initial_load</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_apply_initial_load" title="Permalink to this definition">¶</a></dt>
<dd><p>If <code class="docutils literal notranslate"><span class="pre">true</span></code>, apply initial loading field to crack slab</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_bulk_filename">
<code class="descname">crack_bulk_filename</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_bulk_filename" title="Permalink to this definition">¶</a></dt>
<dd><p>Input file containing primitive cell</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_check_coordination_atom_type">
<code class="descname">crack_check_coordination_atom_type</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_check_coordination_atom_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Atom type we check the coordination for</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_check_coordination_critical_nneigh">
<code class="descname">crack_check_coordination_critical_nneigh</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_check_coordination_critical_nneigh" title="Permalink to this definition">¶</a></dt>
<dd><p>Critical number of neighbours in the connectivity checking</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_check_coordination_region">
<code class="descname">crack_check_coordination_region</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_check_coordination_region" title="Permalink to this definition">¶</a></dt>
<dd><p>Region (+/- around y=0 level) where the atomic coordination is checked.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_check_surface_coordination">
<code class="descname">crack_check_surface_coordination</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_check_surface_coordination" title="Permalink to this definition">¶</a></dt>
<dd><p>Checking of the surface coordination before generating the crack seed</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_curvature">
<code class="descname">crack_curvature</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_curvature" title="Permalink to this definition">¶</a></dt>
<dd><p>Curvature used when crack_curved_front=T</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_curved_front">
<code class="descname">crack_curved_front</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_curved_front" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, initialise slab with a curved crack front</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_dislo_seed">
<code class="descname">crack_dislo_seed</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_dislo_seed" title="Permalink to this definition">¶</a></dt>
<dd><p>atom at the core of the dislocation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_double_ended">
<code class="descname">crack_double_ended</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_double_ended" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, we do a double ended crack with periodic boundary conditions along <span class="math notranslate nohighlight">\(x\)</span> direction.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_edge_fix_tol">
<code class="descname">crack_edge_fix_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_edge_fix_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>How close must an atom be to top or bottom to be fixed. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_element">
<code class="descname">crack_element</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_element" title="Permalink to this definition">¶</a></dt>
<dd><p>Element to make slab from. Supported so far: Si, C, SiC, SiO</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_fix_dipoles">
<code class="descname">crack_fix_dipoles</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_fix_dipoles" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, we keep fixed dipoles for atoms at the edges.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_fix_dipoles_tol">
<code class="descname">crack_fix_dipoles_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_fix_dipoles_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>How close must an atom be to top or bottom to keep fixed its dipole. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_fix_sides">
<code class="descname">crack_fix_sides</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_fix_sides" title="Permalink to this definition">¶</a></dt>
<dd><p>If true fix atoms close to left and right edges of slab</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_free_surfaces">
<code class="descname">crack_free_surfaces</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_free_surfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, crack is 3D with free surfaces at z= +/- depth/2</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_front_alpha">
<code class="descname">crack_front_alpha</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_front_alpha" title="Permalink to this definition">¶</a></dt>
<dd><p>Value of alpha to use when tip_method=alpha_shape</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_front_angle_threshold">
<code class="descname">crack_front_angle_threshold</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_front_angle_threshold" title="Permalink to this definition">¶</a></dt>
<dd><p>Maximum bearing for segments to be included in crack front</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_front_window_size">
<code class="descname">crack_front_window_size</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_front_window_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Size of windows along crack front. Should be roughly equal to lattice periodicity in this direction.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_g">
<code class="descname">crack_g</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_g" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial energy release rate loading in J/m:math:<cite>^2</cite> (override strain)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_g_increment">
<code class="descname">crack_g_increment</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_g_increment" title="Permalink to this definition">¶</a></dt>
<dd><p>Rate of loading, expressed as increment in G (override strain_increment)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_graphene_notch_height">
<code class="descname">crack_graphene_notch_height</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_graphene_notch_height" title="Permalink to this definition">¶</a></dt>
<dd><p>Height of graphene notch. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_graphene_notch_width">
<code class="descname">crack_graphene_notch_width</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_graphene_notch_width" title="Permalink to this definition">¶</a></dt>
<dd><p>Width of graphene notch. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_graphene_theta">
<code class="descname">crack_graphene_theta</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_graphene_theta" title="Permalink to this definition">¶</a></dt>
<dd><p>Rotation angle of graphene plane, in radians.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_height">
<code class="descname">crack_height</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_height" title="Permalink to this definition">¶</a></dt>
<dd><p>Height of crack slab, in AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_initial_velocity_field">
<code class="descname">crack_initial_velocity_field</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_initial_velocity_field" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, initialise velocity field with dU/dc</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_lattice_guess">
<code class="descname">crack_lattice_guess</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_lattice_guess" title="Permalink to this definition">¶</a></dt>
<dd><p>Guess at bulk lattice parameter, used to obtain accurate result. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_load_interp_length">
<code class="descname">crack_load_interp_length</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_load_interp_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length over which linear interpolation between k-field
and uniform strain field is carried out</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_loading">
<code class="descname">crack_loading</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_loading" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">uniform</span></code> for constant load,
<code class="docutils literal notranslate"><span class="pre">ramp</span></code> for linearly decreasing load along <span class="math notranslate nohighlight">\(x\)</span>,
<code class="docutils literal notranslate"><span class="pre">kfield</span></code> for Irwin plane strain K-field,
<code class="docutils literal notranslate"><span class="pre">interp_kfield_uniform</span></code> to linearly interpolate between k-field
(at crack tip) and uniform at distance <code class="docutils literal notranslate"><span class="pre">crack_load_interp_length</span></code>
<code class="docutils literal notranslate"><span class="pre">reduce_uniform</span></code> for reducing load</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_name">
<code class="descname">crack_name</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_name" title="Permalink to this definition">¶</a></dt>
<dd><p>Crack name, in format <code class="docutils literal notranslate"><span class="pre">(abc)[def]</span></code> with negative indices
denoted by a trailing <code class="docutils literal notranslate"><span class="pre">b</span></code> (for bar), e.g. <code class="docutils literal notranslate"><span class="pre">(111)[11b0]</span></code>.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_num_layers">
<code class="descname">crack_num_layers</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_num_layers" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of primitive cells in <span class="math notranslate nohighlight">\(z\)</span> direction</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_ramp_end_g">
<code class="descname">crack_ramp_end_g</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_ramp_end_g" title="Permalink to this definition">¶</a></dt>
<dd><p>Loading at end of ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_ramp_length">
<code class="descname">crack_ramp_length</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_ramp_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length of ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_ramp_start_length">
<code class="descname">crack_ramp_start_length</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_ramp_start_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length of the region in between the crack tip and the start of the ramp for the case <code class="docutils literal notranslate"><span class="pre">crack_loading=&quot;ramp&quot;</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_relax_bulk">
<code class="descname">crack_relax_bulk</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_relax_bulk" title="Permalink to this definition">¶</a></dt>
<dd><p>If true (default) relax bulk cell using classical potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_relax_loading_field">
<code class="descname">crack_relax_loading_field</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_relax_loading_field" title="Permalink to this definition">¶</a></dt>
<dd><p>Should <code class="docutils literal notranslate"><span class="pre">makecrack</span></code> relax the applied loading field</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_rescale_x">
<code class="descname">crack_rescale_x</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_rescale_x" title="Permalink to this definition">¶</a></dt>
<dd><p>Rescale atomsatoms  in x direction by v</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_rescale_x_z">
<code class="descname">crack_rescale_x_z</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_rescale_x_z" title="Permalink to this definition">¶</a></dt>
<dd><p>Rescale atomsatoms  in x direction by v and in z direction by v2</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_seed_embed_tol">
<code class="descname">crack_seed_embed_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_seed_embed_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>Atoms closer than this distance from crack tip will be used to seed embed region. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_seed_length">
<code class="descname">crack_seed_length</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_seed_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length of seed crack. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_slab_filename">
<code class="descname">crack_slab_filename</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_slab_filename" title="Permalink to this definition">¶</a></dt>
<dd><p>Input file to use instead of generating slabs.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_strain">
<code class="descname">crack_strain</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial applied strain</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_strain_increment">
<code class="descname">crack_strain_increment</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_strain_increment" title="Permalink to this definition">¶</a></dt>
<dd><p>Rate of loading, expressed as strain of initial loading</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_strain_zone_width">
<code class="descname">crack_strain_zone_width</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_strain_zone_width" title="Permalink to this definition">¶</a></dt>
<dd><p>Distance over which strain increases. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_structure">
<code class="descname">crack_structure</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_structure" title="Permalink to this definition">¶</a></dt>
<dd><p>Structure: so far <code class="docutils literal notranslate"><span class="pre">diamond</span></code> and <code class="docutils literal notranslate"><span class="pre">graphene</span></code> are supported</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_thermostat_ramp_length">
<code class="descname">crack_thermostat_ramp_length</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_thermostat_ramp_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length of thermostat ramp used for stadium damping at left and right edges</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_thermostat_ramp_max_tau">
<code class="descname">crack_thermostat_ramp_max_tau</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_thermostat_ramp_max_tau" title="Permalink to this definition">¶</a></dt>
<dd><p>Value of thermostat tau at end of ramp, in fs.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_tip_grid_size">
<code class="descname">crack_tip_grid_size</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_tip_grid_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Size (in A) of grid used for locating crack tips</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_tip_method">
<code class="descname">crack_tip_method</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_tip_method" title="Permalink to this definition">¶</a></dt>
<dd><p>One of <code class="docutils literal notranslate"><span class="pre">coordination</span></code>, <code class="docutils literal notranslate"><span class="pre">percolation</span></code>, <code class="docutils literal notranslate"><span class="pre">local_energy</span></code> or <code class="docutils literal notranslate"><span class="pre">alpha_shape</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_tip_min_separation">
<code class="descname">crack_tip_min_separation</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_tip_min_separation" title="Permalink to this definition">¶</a></dt>
<dd><p>Minimum seperation (in A) between a pair of crack tips for them to be considered distinct</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_vacuum_size">
<code class="descname">crack_vacuum_size</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_vacuum_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Amount of vacuum around crack slab. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_width">
<code class="descname">crack_width</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_width" title="Permalink to this definition">¶</a></dt>
<dd><p>Width of crack slab, in AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_x_shift">
<code class="descname">crack_x_shift</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_x_shift" title="Permalink to this definition">¶</a></dt>
<dd><p>Shift required to get “nice” surface terminations on vertical edges</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_y_shift">
<code class="descname">crack_y_shift</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_y_shift" title="Permalink to this definition">¶</a></dt>
<dd><p>Shift required to align y=0 with centre of a vertical bond.
This value is only used for unknown values of <code class="docutils literal notranslate"><span class="pre">crack_name</span></code>. Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.crack_z">
<code class="descname">crack_z</code><a class="headerlink" href="#quippy.crack.CrackParams.crack_z" title="Permalink to this definition">¶</a></dt>
<dd><p>Initialised automatically from crack element</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.fit_hops">
<code class="descname">fit_hops</code><a class="headerlink" href="#quippy.crack.CrackParams.fit_hops" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of hops used to generate fit region from embed region</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.fit_method">
<code class="descname">fit_method</code><a class="headerlink" href="#quippy.crack.CrackParams.fit_method" title="Permalink to this definition">¶</a></dt>
<dd><p>Method to use for force mixing: should be one of
begin{itemize}</p>
<blockquote>
<div><p>item <code class="docutils literal notranslate"><span class="pre">lotf_adj_pot_svd</span></code> — LOTF using SVD to optimised the Adj Pot
item <code class="docutils literal notranslate"><span class="pre">lotf_adj_pot_minim</span></code> — LOTF using conjugate gradients to optimise the Adj Pot
item <code class="docutils literal notranslate"><span class="pre">lotf_adj_pot_sw</span></code> — LOTF using old style SW Adj Pot
item <code class="docutils literal notranslate"><span class="pre">conserve_momentum</span></code> — divide the total force on QM region over the fit atoms to conserve momentum
item <code class="docutils literal notranslate"><span class="pre">force_mixing</span></code> — force mixing with details depending on values of</p>
<blockquote>
<div><code class="docutils literal notranslate"><span class="pre">buffer_hops</span></code>, <code class="docutils literal notranslate"><span class="pre">transtion_hops</span></code> and <code class="docutils literal notranslate"><span class="pre">weight_interpolation</span></code></div></blockquote>
<dl class="docutils">
<dt>item <code class="docutils literal notranslate"><span class="pre">force_mixing_abrupt</span></code> — simply use QM forces on QM atoms and MM forces on MM atoms</dt>
<dd>(shorthand for <code class="docutils literal notranslate"><span class="pre">method=force_mixing</span> <span class="pre">buffer_hops=0</span> <span class="pre">transition_hops=0</span></code>)</dd>
<dt>item <code class="docutils literal notranslate"><span class="pre">force_mixing_smooth</span></code> — use QM forces in QM region, MM forces in MM region and</dt>
<dd>linearly interpolate in buffer region  (shorthand for <code class="docutils literal notranslate"><span class="pre">method=force_mixing</span> <span class="pre">weight_interpolation=hop_ramp</span></code>)</dd>
<dt>item <code class="docutils literal notranslate"><span class="pre">force_mixing_super_smooth</span></code> — as above, but weight forces on each atom by distance from</dt>
<dd>centre of mass of core region (shorthand for <code class="docutils literal notranslate"><span class="pre">method=force_mixing</span> <span class="pre">weight_interpolation=distance_ramp</span></code>)</dd>
</dl>
</div></blockquote>
<p>end{itemize}</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.fit_spring_hops">
<code class="descname">fit_spring_hops</code><a class="headerlink" href="#quippy.crack.CrackParams.fit_spring_hops" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of hops used when creating list of springs</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.force_integration_end_file">
<code class="descname">force_integration_end_file</code><a class="headerlink" href="#quippy.crack.CrackParams.force_integration_end_file" title="Permalink to this definition">¶</a></dt>
<dd><p>XYZ file containing ending configuration for force integration.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.force_integration_n_steps">
<code class="descname">force_integration_n_steps</code><a class="headerlink" href="#quippy.crack.CrackParams.force_integration_n_steps" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of steps to take in force integration</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.hack_fit_on_eqm_coordination_only">
<code class="descname">hack_fit_on_eqm_coordination_only</code><a class="headerlink" href="#quippy.crack.CrackParams.hack_fit_on_eqm_coordination_only" title="Permalink to this definition">¶</a></dt>
<dd><p>Only include fit atoms that have coordination
number equal to <code class="docutils literal notranslate"><span class="pre">md_eqm_coordination</span></code> (used for graphene).</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.hack_qm_zero_z_force">
<code class="descname">hack_qm_zero_z_force</code><a class="headerlink" href="#quippy.crack.CrackParams.hack_qm_zero_z_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Zero <span class="math notranslate nohighlight">\(z\)</span> component of all forces (used for graphene)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_backup">
<code class="descname">io_backup</code><a class="headerlink" href="#quippy.crack.CrackParams.io_backup" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, create backups of check files</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_checkpoint_interval">
<code class="descname">io_checkpoint_interval</code><a class="headerlink" href="#quippy.crack.CrackParams.io_checkpoint_interval" title="Permalink to this definition">¶</a></dt>
<dd><p>Interval between writing checkpoint files, in fs.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_checkpoint_path">
<code class="descname">io_checkpoint_path</code><a class="headerlink" href="#quippy.crack.CrackParams.io_checkpoint_path" title="Permalink to this definition">¶</a></dt>
<dd><p>Path to write checkpoint files to. Set this to local scratch space to avoid doing
lots of I/O to a network drive. Default is current directory.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_mpi_print_all">
<code class="descname">io_mpi_print_all</code><a class="headerlink" href="#quippy.crack.CrackParams.io_mpi_print_all" title="Permalink to this definition">¶</a></dt>
<dd><p>Print output on all nodes. Useful for debugging. Default .false.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_netcdf">
<code class="descname">io_netcdf</code><a class="headerlink" href="#quippy.crack.CrackParams.io_netcdf" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, output in NetCDF format instead of XYZ</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_print_all_properties">
<code class="descname">io_print_all_properties</code><a class="headerlink" href="#quippy.crack.CrackParams.io_print_all_properties" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, print all atom properties to movie file. This will generate large
files but is useful for debugging.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_print_interval">
<code class="descname">io_print_interval</code><a class="headerlink" href="#quippy.crack.CrackParams.io_print_interval" title="Permalink to this definition">¶</a></dt>
<dd><p>Interval between movie XYZ frames, in fs.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_print_properties">
<code class="descname">io_print_properties</code><a class="headerlink" href="#quippy.crack.CrackParams.io_print_properties" title="Permalink to this definition">¶</a></dt>
<dd><p>List of properties to print to movie file.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_timing">
<code class="descname">io_timing</code><a class="headerlink" href="#quippy.crack.CrackParams.io_timing" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, enable timing (default false)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.io_verbosity">
<code class="descname">io_verbosity</code><a class="headerlink" href="#quippy.crack.CrackParams.io_verbosity" title="Permalink to this definition">¶</a></dt>
<dd><p>Output verbosity. In XML file, this should be specified as one of
<code class="docutils literal notranslate"><span class="pre">ERROR</span></code>, <code class="docutils literal notranslate"><span class="pre">SILENT</span></code>, <code class="docutils literal notranslate"><span class="pre">NORMAL</span></code>, <code class="docutils literal notranslate"><span class="pre">VERBOSE</span></code>, <code class="docutils literal notranslate"><span class="pre">NERD</span></code> or <code class="docutils literal notranslate"><span class="pre">ANAL</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_eps_guess">
<code class="descname">minim_eps_guess</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_eps_guess" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial guess for line search step size <span class="math notranslate nohighlight">\(\epsilon\)</span>.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_fire_dt0">
<code class="descname">minim_fire_dt0</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_fire_dt0" title="Permalink to this definition">¶</a></dt>
<dd><p>If using fire_minim, the initial step size</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_fire_dt_max">
<code class="descname">minim_fire_dt_max</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_fire_dt_max" title="Permalink to this definition">¶</a></dt>
<dd><p>If using fire_minim, the maximum step size</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_linminroutine">
<code class="descname">minim_linminroutine</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_linminroutine" title="Permalink to this definition">¶</a></dt>
<dd><p>Linmin routine, e.g. <code class="docutils literal notranslate"><span class="pre">FAST_LINMIN</span></code> for classical potentials with total energy, or
<code class="docutils literal notranslate"><span class="pre">LINMIN_DERIV</span></code> when doing a LOTF hybrid simulation and only forces are available.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_max_steps">
<code class="descname">minim_max_steps</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_max_steps" title="Permalink to this definition">¶</a></dt>
<dd><p>Maximum number of minimisation steps.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_method">
<code class="descname">minim_method</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_method" title="Permalink to this definition">¶</a></dt>
<dd><p>Minimisation method: use <code class="docutils literal notranslate"><span class="pre">cg</span></code> for conjugate gradients or <code class="docutils literal notranslate"><span class="pre">sd</span></code> for steepest descent.
See <code class="docutils literal notranslate"><span class="pre">minim()</span></code> in <code class="docutils literal notranslate"><span class="pre">libAtoms/minimisation.f95</span></code> for details.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_minimise_mm">
<code class="descname">minim_minimise_mm</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_minimise_mm" title="Permalink to this definition">¶</a></dt>
<dd><p>Should we minimise classical degrees of freedom before each QM force evaluation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_args_str">
<code class="descname">minim_mm_args_str</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_args_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Args string to be passed to MM calc() routine</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_eps_guess">
<code class="descname">minim_mm_eps_guess</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_eps_guess" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial guess for line search <span class="math notranslate nohighlight">\(\epsilon\)</span> for MM minimisation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_linminroutine">
<code class="descname">minim_mm_linminroutine</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_linminroutine" title="Permalink to this definition">¶</a></dt>
<dd><p>Linmin routine for MM minimisation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_max_steps">
<code class="descname">minim_mm_max_steps</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_max_steps" title="Permalink to this definition">¶</a></dt>
<dd><p>Maximum number of cg cycles for MM minimisation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_method">
<code class="descname">minim_mm_method</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_method" title="Permalink to this definition">¶</a></dt>
<dd><p>Minim method for MM minimisation, e.g. <code class="docutils literal notranslate"><span class="pre">cg</span></code> for conjugate gradients</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_mm_tol">
<code class="descname">minim_mm_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_mm_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>Target force tolerance for MM minimisation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_print_output">
<code class="descname">minim_print_output</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_print_output" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of steps between XYZ confgurations printed</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.minim_tol">
<code class="descname">minim_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.minim_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>Target force tolerance - geometry optimisation is considered to be
converged when <span class="math notranslate nohighlight">\(|\mathbf{f}|^2 &lt;\)</span> <code class="docutils literal notranslate"><span class="pre">tol</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_args">
<code class="descname">qm_args</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_args" title="Permalink to this definition">¶</a></dt>
<dd><p>Arguments used to initialise QM potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_args_str">
<code class="descname">qm_args_str</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_args_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Arguments used by QM potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_buffer_hops">
<code class="descname">qm_buffer_hops</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_buffer_hops" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of bond hops used for buffer region</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_calc_force_error">
<code class="descname">qm_calc_force_error</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_calc_force_error" title="Permalink to this definition">¶</a></dt>
<dd><p>Do a full QM calculation at each stage in extrap and interp to measure force error</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_clusters">
<code class="descname">qm_clusters</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_clusters" title="Permalink to this definition">¶</a></dt>
<dd><p>Should we carve clusters? Default true.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_cp2k">
<code class="descname">qm_cp2k</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_cp2k" title="Permalink to this definition">¶</a></dt>
<dd><p>Enable CP2K mode. Default false.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_even_electrons">
<code class="descname">qm_even_electrons</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_even_electrons" title="Permalink to this definition">¶</a></dt>
<dd><p>Discard a hydrogen if necessary to give an overall non-spin-polarised cluster</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_extra_args_str">
<code class="descname">qm_extra_args_str</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_extra_args_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Extra arguments passed to ForceMixing potential</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_force_periodic">
<code class="descname">qm_force_periodic</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_force_periodic" title="Permalink to this definition">¶</a></dt>
<dd><p>Force clusters to be periodic in <span class="math notranslate nohighlight">\(z\)</span> direction.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_buffer">
<code class="descname">qm_hysteretic_buffer</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_buffer" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, manage the buffer region hysteritcally</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_buffer_inner_radius">
<code class="descname">qm_hysteretic_buffer_inner_radius</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_inner_radius" title="Permalink to this definition">¶</a></dt>
<dd><p>Inner radius used for hystertic buffer region</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_buffer_nneighb_only">
<code class="descname">qm_hysteretic_buffer_nneighb_only</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_nneighb_only" title="Permalink to this definition">¶</a></dt>
<dd><p>Should hysteretic buffer be formed by nearest neighbor hopping?</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_buffer_outer_radius">
<code class="descname">qm_hysteretic_buffer_outer_radius</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_buffer_outer_radius" title="Permalink to this definition">¶</a></dt>
<dd><p>Outer radius used for hystertic buffer region</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_connect">
<code class="descname">qm_hysteretic_connect</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_connect" title="Permalink to this definition">¶</a></dt>
<dd><p>Enable hysteretic connectivity</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_connect_cluster_radius">
<code class="descname">qm_hysteretic_connect_cluster_radius</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_connect_cluster_radius" title="Permalink to this definition">¶</a></dt>
<dd><p>Radius other which to keep track of hysteretic connectivity info. Default 10.0 A.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_connect_inner_factor">
<code class="descname">qm_hysteretic_connect_inner_factor</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_connect_inner_factor" title="Permalink to this definition">¶</a></dt>
<dd><p>Inner bond factor. Default 1.2</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_hysteretic_connect_outer_factor">
<code class="descname">qm_hysteretic_connect_outer_factor</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_hysteretic_connect_outer_factor" title="Permalink to this definition">¶</a></dt>
<dd><p>Outer bond factor. Default 1.5</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_little_clusters">
<code class="descname">qm_little_clusters</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_little_clusters" title="Permalink to this definition">¶</a></dt>
<dd><p>One big cluster or lots of little ones?</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_randomise_buffer">
<code class="descname">qm_randomise_buffer</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_randomise_buffer" title="Permalink to this definition">¶</a></dt>
<dd><p>Randomise positions of outer layer of buffer atoms slightly to avoid systematic errors.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_rescale_r">
<code class="descname">qm_rescale_r</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_rescale_r" title="Permalink to this definition">¶</a></dt>
<dd><p>If true, rescale space in QM cluster to match QM lattice constant</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_terminate">
<code class="descname">qm_terminate</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_terminate" title="Permalink to this definition">¶</a></dt>
<dd><p>Terminate clusters with hydrogen atoms</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_transition_hops">
<code class="descname">qm_transition_hops</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_transition_hops" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of transition hops used for buffer region</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.qm_vacuum_size">
<code class="descname">qm_vacuum_size</code><a class="headerlink" href="#quippy.crack.CrackParams.qm_vacuum_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Amount of vacuum surrounding cluster in non-periodic directions (<span class="math notranslate nohighlight">\(x\)</span> and <span class="math notranslate nohighlight">\(y\)</span> at least). Unit:~AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.quasi_static_tip_move_tol">
<code class="descname">quasi_static_tip_move_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.quasi_static_tip_move_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>How far cracktip must advance before we consider fracture to have occurred.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_cutoff_plane">
<code class="descname">selection_cutoff_plane</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_cutoff_plane" title="Permalink to this definition">¶</a></dt>
<dd><p>Only atoms within this distance from crack tip are candidates for QM selection. Unit: AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_directionality">
<code class="descname">selection_directionality</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_directionality" title="Permalink to this definition">¶</a></dt>
<dd><p>Require good directionality of spring space spanning for atoms in embed region.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_edge_tol">
<code class="descname">selection_edge_tol</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_edge_tol" title="Permalink to this definition">¶</a></dt>
<dd><p>Size of region at edges of crack slab which is ignored for selection purposes.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_ellipse">
<code class="descname">selection_ellipse</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_ellipse" title="Permalink to this definition">¶</a></dt>
<dd><p>Principal radii of selection ellipse along <span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span> and <span class="math notranslate nohighlight">\(z\)</span> in AA{}.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_ellipse_bias">
<code class="descname">selection_ellipse_bias</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_ellipse_bias" title="Permalink to this definition">¶</a></dt>
<dd><p>Shift applied to ellipses, expressed as fraction of ellipse radius in <span class="math notranslate nohighlight">\(x\)</span> direction.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_ellipse_buffer">
<code class="descname">selection_ellipse_buffer</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_ellipse_buffer" title="Permalink to this definition">¶</a></dt>
<dd><p>Difference in size between inner and outer selection ellipses, i.e. amount of hysteresis.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_max_qm_atoms">
<code class="descname">selection_max_qm_atoms</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_max_qm_atoms" title="Permalink to this definition">¶</a></dt>
<dd><p>Maximum number of QM atoms to select</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_method">
<code class="descname">selection_method</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_method" title="Permalink to this definition">¶</a></dt>
<dd><p>One of <code class="docutils literal notranslate"><span class="pre">static</span></code>, <code class="docutils literal notranslate"><span class="pre">coordination</span></code>, <code class="docutils literal notranslate"><span class="pre">crack_front</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.selection_update_interval">
<code class="descname">selection_update_interval</code><a class="headerlink" href="#quippy.crack.CrackParams.selection_update_interval" title="Permalink to this definition">¶</a></dt>
<dd><p>intervals between QM selection updates, defaults to 0.0_dp meaning <code class="docutils literal notranslate"><span class="pre">every</span> <span class="pre">step</span></code></p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.simulation_classical">
<code class="descname">simulation_classical</code><a class="headerlink" href="#quippy.crack.CrackParams.simulation_classical" title="Permalink to this definition">¶</a></dt>
<dd><p>Perform a purely classical simulation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.simulation_force_initial_load_step">
<code class="descname">simulation_force_initial_load_step</code><a class="headerlink" href="#quippy.crack.CrackParams.simulation_force_initial_load_step" title="Permalink to this definition">¶</a></dt>
<dd><p>Force a load step at beginning of simulation</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.simulation_initial_state">
<code class="descname">simulation_initial_state</code><a class="headerlink" href="#quippy.crack.CrackParams.simulation_initial_state" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial state. Overrides value read from input atoms structure</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.simulation_seed">
<code class="descname">simulation_seed</code><a class="headerlink" href="#quippy.crack.CrackParams.simulation_seed" title="Permalink to this definition">¶</a></dt>
<dd><p>Random number seed. Use zero for a random seed, or a particular value to repeat a previous run.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.crack.CrackParams.simulation_task">
<code class="descname">simulation_task</code><a class="headerlink" href="#quippy.crack.CrackParams.simulation_task" title="Permalink to this definition">¶</a></dt>
<dd><p>Task to perform: <code class="docutils literal notranslate"><span class="pre">md</span></code>, <code class="docutils literal notranslate"><span class="pre">minim</span></code>, etc.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="quippy.crack.ConstantStrainRate">
<em class="property">class </em><code class="descclassname">quippy.crack.</code><code class="descname">ConstantStrainRate</code><span class="sig-paren">(</span><em>orig_height</em>, <em>delta_strain</em>, <em>mask=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#ConstantStrainRate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.ConstantStrainRate" title="Permalink to this definition">¶</a></dt>
<dd><p>Constraint which increments epsilon_yy at a constant strain rate</p>
<p>Rescaling is applied only to atoms where <cite>mask</cite> is True (default is all atoms)</p>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.crack.ConstantStrainRate.apply_strain" title="quippy.crack.ConstantStrainRate.apply_strain"><code class="xref py py-obj docutils literal notranslate"><span class="pre">apply_strain</span></code></a>(atoms[,&nbsp;rigid_constraints])</td>
<td>Applies a constant strain to the system.</td>
</tr>
</tbody>
</table>
<dl class="method">
<dt id="quippy.crack.ConstantStrainRate.apply_strain">
<code class="descname">apply_strain</code><span class="sig-paren">(</span><em>atoms</em>, <em>rigid_constraints=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#ConstantStrainRate.apply_strain"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.ConstantStrainRate.apply_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Applies a constant strain to the system.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>atoms</strong> <span class="classifier-delimiter">:</span> <span class="classifier">ASE.atoms or quippy.Atoms</span></dt>
<dd><p class="first last">Atomic configuration.</p>
</dd>
<dt><strong>rigid_constraints</strong> <span class="classifier-delimiter">:</span> <span class="classifier">boolean</span></dt>
<dd><p class="first last">Apply (or not apply) strain to every atom.
i.e. allow constrainted atoms to move during strain application</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_is_edge_atom">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_is_edge_atom</code><span class="sig-paren">(</span><em>slab</em>, <em>i</em>, <em>edge_gap</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_is_edge_atom" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns true if atom <code class="docutils literal notranslate"><span class="pre">i</span></code> is near to an open surface of slab.
Open surfaces are planes at <span class="math notranslate nohighlight">\(x = \pm\)</span> and <span class="math notranslate nohighlight">\(y = \pm\)</span>.
“Near to” means within <code class="docutils literal notranslate"><span class="pre">edge_gap</span></code> of the surface.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>edge_gap</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_is_edge_atom</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_is_edge_atom</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_parse_name">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_parse_name</code><span class="sig-paren">(</span><em>crackname</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_parse_name" title="Permalink to this definition">¶</a></dt>
<dd><p>Parse crack name in the format is (ijk)[lmn], with negative numbers
denoted by a trailing <code class="docutils literal notranslate"><span class="pre">b</span></code> (short for <code class="docutils literal notranslate"><span class="pre">bar</span></code>), e.g. <code class="docutils literal notranslate"><span class="pre">(111)[11b0]</span></code>
Axes of crack slab returned as <span class="math notranslate nohighlight">\(3\times3\)</span> matrix with columns
<span class="math notranslate nohighlight">\(\mathbf{x}\)</span>,:math:<cite>mathbf{y}</cite>,:math:<cite>mathbf{z}</cite>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>crackname</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>axes</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-2 array(‘d’) with bounds (3,3)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_parse_name</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_hybrid_calc_args">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_hybrid_calc_args</code><span class="sig-paren">(</span><em>qm_args_str</em>, <em>extra_qm_args</em>, <em>mm_args_str</em>, <em>extra_mm_args</em>, <em>extra_args_str</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_hybrid_calc_args" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>qm_args_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>extra_qm_args</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>mm_args_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>extra_mm_args</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>extra_args_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_hybrid_calc_args</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_hybrid_calc_args</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_g_to_k">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_g_to_k</code><span class="sig-paren">(</span><em>g</em>, <em>e</em>, <em>v</em><span class="optional">[</span>, <em>mode</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_g_to_k" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert from energy release rate <span class="math notranslate nohighlight">\(G\)</span> to stress intensity factor <span class="math notranslate nohighlight">\(K\)</span>
Units: G (J/m:math:<cite>^2</cite>), E (GPa), K (Pa sqrt(m))</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>mode</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_k</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_g_to_k</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.percolation_step">
<code class="descclassname">quippy.crack.</code><code class="descname">percolation_step</code><span class="sig-paren">(</span><em>grid</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.percolation_step" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>grid</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-3 array(‘i’) with bounds (qp_n0,qp_n1,qp_n2)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_percolation_step</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">percolation_step</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_setup_marks">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_setup_marks</code><span class="sig-paren">(</span><em>crack_slab</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_setup_marks" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_setup_marks</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_update_selection_crack_front">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_update_selection_crack_front</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_update_selection_crack_front" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_update_selection_crack_front</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_is_topbottom_edge_atom">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_is_topbottom_edge_atom</code><span class="sig-paren">(</span><em>slab</em>, <em>i</em>, <em>edge_gap</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_is_topbottom_edge_atom" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns true if atom <code class="docutils literal notranslate"><span class="pre">i</span></code> is the topbottom surface of slab
Topbottom surfaces are planes at <span class="math notranslate nohighlight">\(y = \pm\)</span></p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>edge_gap</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_is_topbottom_edge_atom</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_is_topbottom_edge_atom</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_make_slab">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_make_slab</code><span class="sig-paren">(</span><em>params</em>, <em>classicalpot</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_make_slab" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>classicalpot</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="potential.html#quippy.potential.Potential" title="quippy.potential.Potential"><code class="xref py py-class docutils literal notranslate"><span class="pre">Potential</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>crack_slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>width</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>v2</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>bulk</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_make_slab</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_apply_strain_ramp">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_apply_strain_ramp</code><span class="sig-paren">(</span><em>at</em>, <em>g1</em>, <em>g2</em>, <em>d1</em>, <em>d2</em>, <em>d3</em>, <em>d4</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_apply_strain_ramp" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>g1</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>g2</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>d1</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>d2</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>d3</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>d4</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_apply_strain_ramp</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_strain_to_g">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_strain_to_g</code><span class="sig-paren">(</span><em>strain</em>, <em>e</em>, <em>v</em>, <em>height</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_strain_to_g" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculate energy release rate <span class="math notranslate nohighlight">\(G\)</span> from strain using
:math:<code class="docutils literal notranslate"><span class="pre">G</span> <span class="pre">=</span> <span class="pre">\frac{1}{2}</span> <span class="pre">\frac{E}{1-\nu^2}</span> <span class="pre">\epsilon^2</span> <span class="pre">h:math:</span></code>
from thin strip result. Quantities are:
<code class="docutils literal notranslate"><span class="pre">strain</span></code>,:math:<cite>epsilon</cite>, dimensionless ratio <span class="math notranslate nohighlight">\(\frac{\Delta y}{y}\)</span>;
<code class="docutils literal notranslate"><span class="pre">E</span></code>, <span class="math notranslate nohighlight">\(E\)</span>,  Young’s modulus, GPa;
<code class="docutils literal notranslate"><span class="pre">v</span></code>, <span class="math notranslate nohighlight">\(\nu\)</span>, Poisson ratio, dimensionless;
<code class="docutils literal notranslate"><span class="pre">height</span></code>, <span class="math notranslate nohighlight">\(h\)</span> AA{}, 10:math:<cite>^{-10}`~m;
``G`</cite>, Energy release rate, J/m:math:<cite>^2</cite>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>strain</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_strain_to_g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_strain_to_g</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_tip_coordination">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_tip_coordination</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="optional">[</span>, <em>n_tip_atoms</em>, <em>tip_indices</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_find_tip_coordination" title="Permalink to this definition">¶</a></dt>
<dd><p>Return <span class="math notranslate nohighlight">\(x\)</span> coordinate of rightmost undercoordinated atom</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>n_tip_atoms</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
<dt><strong>tip_indices</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-1 array(‘i’) with bounds (qp_n0), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-1 array(‘d’) with bounds (2)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_find_tip_coordination</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.in_ellipse">
<code class="descclassname">quippy.crack.</code><code class="descname">in_ellipse</code><span class="sig-paren">(</span><em>d</em>, <em>ellipse</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.in_ellipse" title="Permalink to this definition">¶</a></dt>
<dd><p>Return true if the point <code class="docutils literal notranslate"><span class="pre">d</span></code> is within an ellipse centred at the origin
with the <span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span>, and <span class="math notranslate nohighlight">\(z\)</span> radii specifeid in the vector <code class="docutils literal notranslate"><span class="pre">ellipse</span></code>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>d</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘d’) with bounds (3)</span></dt>
<dd></dd>
<dt><strong>ellipse</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘d’) with bounds (3)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_in_ellipse</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">in_ellipse</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_tip_local_energy">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_tip_local_energy</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_find_tip_local_energy" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_find_tip_local_energy</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_update_selection">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_update_selection</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_update_selection" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_update_selection</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_mm_calc_args">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_mm_calc_args</code><span class="sig-paren">(</span><em>mm_args_str</em>, <em>extra_mm_args</em>, <em>extra_args_str</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_mm_calc_args" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>mm_args_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>extra_mm_args</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>extra_args_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_mm_calc_args</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_mm_calc_args</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_check_coordination_boundaries">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_check_coordination_boundaries</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_check_coordination_boundaries" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_check_coordination_boundaries</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.select_ellipse">
<code class="descclassname">quippy.crack.</code><code class="descname">select_ellipse</code><span class="sig-paren">(</span><em>at</em>, <em>ellipse</em>, <em>ellipse_bias</em>, <em>list</em>, <em>c</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.select_ellipse" title="Permalink to this definition">¶</a></dt>
<dd><p>Select atoms in ellipse centred on an atom and with given principal radii</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>ellipse</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘d’) with bounds (3)</span></dt>
<dd><p class="first last">Principal radii of ellipse in <span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span> and <span class="math notranslate nohighlight">\(z\)</span> directions</p>
</dd>
<dt><strong>ellipse_bias</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘d’) with bounds (3)</span></dt>
<dd><p class="first last">Shift ellipse, positive values forward</p>
</dd>
<dt><strong>list</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="table.html#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object</span></dt>
<dd><p class="first last">On exit contains indexes of selected atoms, which
are also reachable by nearest neighbour  bond hopping starting from c</p>
</dd>
<dt><strong>c</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">Ellipse is centred around atom <code class="docutils literal notranslate"><span class="pre">c</span></code>.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">select_ellipse</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_uniform_load">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_uniform_load</code><span class="sig-paren">(</span><em>at</em>, <em>params</em>, <em>l_crack_pos</em>, <em>r_crack_pos</em>, <em>zone_width</em>, <em>n0</em>, <em>n1</em><span class="optional">[</span>, <em>eps</em>, <em>g</em>, <em>apply_load</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_uniform_load" title="Permalink to this definition">¶</a></dt>
<dd><p>Rescale atoms in slab, with atoms in front of either crack tip
strained in y direction by <code class="docutils literal notranslate"><span class="pre">strain</span></code> and atoms behind crack tip
rigidly shifted to keep top and bottom edges flat. A transition
zone is created in between with linearly varying strain to
avoid creation of defects.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>    <span class="o">--------------------------------------</span>
    <span class="o">|</span>           <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>            <span class="o">|</span>
    <span class="o">|</span>           <span class="o">|</span>   <span class="o">|</span><span class="n">___</span><span class="o">|</span>   <span class="o">|</span>            <span class="o">|</span>
    <span class="o">|</span>           <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>            <span class="o">|</span>
    <span class="o">|</span>           <span class="o">|</span>   <span class="o">|</span><span class="n">___</span><span class="o">|</span>   <span class="o">|</span>            <span class="o">|</span>
    <span class="o">|</span>           <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>   <span class="o">|</span>            <span class="o">|</span>
    <span class="o">|</span>    <span class="mi">1</span>      <span class="o">|</span> <span class="mi">2</span> <span class="o">|</span> <span class="mi">3</span> <span class="o">|</span> <span class="mi">4</span> <span class="o">|</span>     <span class="mi">5</span>      <span class="o">|</span>
    <span class="o">--------------------------------------</span>
<span class="p">::</span>

   <span class="o">======</span>  <span class="o">===========================================</span>  <span class="o">======</span>
   <span class="n">Region</span>  <span class="n">Position</span>                                      <span class="n">Load</span>
   <span class="o">======</span>  <span class="o">===========================================</span>  <span class="o">======</span>
     <span class="mi">1</span>     <span class="n">x</span> <span class="o">&lt;</span> <span class="n">l_crack_pos</span> <span class="o">-</span> <span class="n">zone_width</span>                 <span class="n">G</span>
     <span class="mi">2</span>     <span class="n">l_crack_pos</span> <span class="o">-</span> <span class="n">zone_width</span> <span class="o">&lt;=</span> <span class="n">x</span> <span class="o">&lt;</span> <span class="n">l_crack_pos</span>  <span class="n">G</span> <span class="o">-</span> <span class="mi">0</span>
     <span class="mi">3</span>     <span class="n">l_crack_pos</span> <span class="o">&lt;</span> <span class="n">x</span> <span class="o">&lt;</span>  <span class="n">r_crack_pos</span>               <span class="mi">0</span>
     <span class="mi">4</span>     <span class="n">r_crack_pos</span> <span class="o">&lt;</span> <span class="n">x</span> <span class="o">&lt;=</span> <span class="n">r_crack_pos</span> <span class="o">+</span> <span class="n">zone_width</span>  <span class="mi">0</span> <span class="o">-</span> <span class="n">G</span>
     <span class="mi">5</span>     <span class="n">x</span>  <span class="n">r_crack_pos</span> <span class="o">+</span> <span class="n">zone_width</span>                 <span class="n">G</span>
   <span class="o">======</span>  <span class="o">===========================================</span>  <span class="o">======</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>l_crack_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>r_crack_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>zone_width</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>eps</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float, optional</span></dt>
<dd></dd>
<dt><strong>g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float, optional</span></dt>
<dd></dd>
<dt><strong>apply_load</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>n0</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">shape(qp_disp,0)</p>
</dd>
<dt><strong>n1</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">shape(qp_disp,1)</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>disp</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-2 array(‘d’) with bounds (qp_n0,qp_n1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_uniform_load</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_g_to_strain">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_g_to_strain</code><span class="sig-paren">(</span><em>g</em>, <em>e</em>, <em>v</em>, <em>height</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_g_to_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculate <span class="math notranslate nohighlight">\(epsilon\)</span> from <span class="math notranslate nohighlight">\(G\)</span>, inverse of above formula.
Units are as the same as <code class="docutils literal notranslate"><span class="pre">crack_strain_to_g</span></code></p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_crack_g_to_strain</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_g_to_strain</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_k_to_g">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_k_to_g</code><span class="sig-paren">(</span><em>k</em>, <em>e</em>, <em>v</em><span class="optional">[</span>, <em>mode</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_k_to_g" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert from stress intensity factor <span class="math notranslate nohighlight">\(K\)</span> to energy release rate <span class="math notranslate nohighlight">\(G\)</span>
Units: G (J/m:math:<cite>^2</cite>), E (GPa), K (Pa sqrt(m))</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>k</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>mode</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_k_to_g</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_update_connect">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_update_connect</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_update_connect" title="Permalink to this definition">¶</a></dt>
<dd><p>Use hysteretic version of calc_connect() so we can use relative cutoffs
Update the connectivity of a crack slab. calc_connect is only called if
necessary (i.e. if the maximal atomic displacement is bigger than
<code class="docutils literal notranslate"><span class="pre">params.md(params.md_stanza)%recalc_connect_factor*params.md(params.md_stanza)%crust</span></code>
The <code class="docutils literal notranslate"><span class="pre">nn</span></code> and <code class="docutils literal notranslate"><span class="pre">changed_nn</span></code> properties are updated each call, with
the (cheaper) nearest neighbour calc_connect always being perforemd.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_update_connect</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_surface_atoms">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_surface_atoms</code><span class="sig-paren">(</span><em>at</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_find_surface_atoms" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_find_surface_atoms</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_tip">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_tip</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_find_tip" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_tips</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="table.html#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_find_tip</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_calc_load_field">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_calc_load_field</code><span class="sig-paren">(</span><em>crack_slab</em>, <em>params</em>, <em>classicalpot</em>, <em>load_method</em>, <em>overwrite_pos</em>, <em>mpi</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_calc_load_field" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>classicalpot</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="potential.html#quippy.potential.Potential" title="quippy.potential.Potential"><code class="xref py py-class docutils literal notranslate"><span class="pre">Potential</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>load_method</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>overwrite_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>mpi</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="mpi_context.html#quippy.mpi_context.MPI_context" title="quippy.mpi_context.MPI_context"><code class="xref py py-class docutils literal notranslate"><span class="pre">MPI_context</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_calc_load_field</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_apply_load_increment">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_apply_load_increment</code><span class="sig-paren">(</span><em>at</em><span class="optional">[</span>, <em>g_increment</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_apply_load_increment" title="Permalink to this definition">¶</a></dt>
<dd><p>Increase the load by adding the the load displacement field
to the atomic positions. The routine recalculates the loading
G and stores it in the atom parameter dictionary.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>g_increment</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_apply_load_increment</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_measure_g">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_measure_g</code><span class="sig-paren">(</span><em>at</em>, <em>e</em>, <em>v</em>, <em>orig_height</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_measure_g" title="Permalink to this definition">¶</a></dt>
<dd><p>Measure the current height of slab and calculate
energy release rate <span class="math notranslate nohighlight">\(G\)</span> from current and original
heights and elastic constants <span class="math notranslate nohighlight">\(E\)</span> and <span class="math notranslate nohighlight">\(\nu\)</span>, using the equation
:math:`` G = frac{1}{2} frac{E}{1-nu^2} frac{{h - h_0}^2}{h_0} :math:``
where <span class="math notranslate nohighlight">\(h_0\)</span> is the original height and <span class="math notranslate nohighlight">\(h\)</span> the new height.
Otherwise, symbols and units are the same as in <code class="docutils literal notranslate"><span class="pre">crack_strain_to_g</span></code>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>e</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>v</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>orig_height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_g</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_measure_g</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_k_field">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_k_field</code><span class="sig-paren">(</span><em>at</em>, <em>k</em><span class="optional">[</span>, <em>mode</em>, <em>sig</em>, <em>disp</em>, <em>do_sig</em>, <em>do_disp</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_k_field" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculate Irwin K-field stresses and/or displacements for all atoms in <code class="docutils literal notranslate"><span class="pre">at</span></code>.
Atomic positions should be the original undistorted bulk crystal positions.
<code class="docutils literal notranslate"><span class="pre">YoungsModulus</span></code> and <code class="docutils literal notranslate"><span class="pre">PoissonRatio_yx</span></code> parameters are extracted from <code class="docutils literal notranslate"><span class="pre">at</span></code>, along
with <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> to specify the location of the crack tip. If neither <code class="docutils literal notranslate"><span class="pre">sig</span></code> nor <code class="docutils literal notranslate"><span class="pre">disp</span></code>
are present thenn properties are added to at if do_disp or do_sig are true.
Stress is in 6 component Voigt notation: <span class="math notranslate nohighlight">\(1=xx, 2=yy, 3=zz, 4=yz, 5=zx\)</span> and <span class="math notranslate nohighlight">\(6=xy\)</span>, and
displacement is a Cartesian vector <span class="math notranslate nohighlight">\((u_x,u_y,u_z)\)</span>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>k</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>mode</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>sig</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘d’) with bounds (qp_n0,qp_n1), optional</span></dt>
<dd></dd>
<dt><strong>disp</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘d’) with bounds (qp_n2,qp_n3), optional</span></dt>
<dd></dd>
<dt><strong>do_sig</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>do_disp</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_k_field</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_tip_percolation">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_tip_percolation</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_find_tip_percolation" title="Permalink to this definition">¶</a></dt>
<dd><p>Locate crack tips within <code class="docutils literal notranslate"><span class="pre">at</span></code> using a percolation algorithm. A grid with cells
of side <code class="docutils literal notranslate"><span class="pre">params.crack_tip_grid_size</span></code> is initialised and populated with 1s in cells containing
atoms and 0s where there are no atoms. The percolation is then
seeded in the void at (0,0,0) for a double-ended crack or (-OrigWidth/2, 0, 0)
for a single-ended crack, and then spreads between connected cells
like a forest fire. A filter is used to remove local minima closer than
<code class="docutils literal notranslate"><span class="pre">params.crack_tip_min_separation</span></code> cells from one another. The result is a Table
with realsize=3 containing the coordinates of the crack tips detected.
If a through-going crack is detected the result table will have size zero.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_tips</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="table.html#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_find_tip_percolation</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_update_selection_coordination">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_update_selection_coordination</code><span class="sig-paren">(</span><em>at</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_update_selection_coordination" title="Permalink to this definition">¶</a></dt>
<dd><p>Update QM selection region for a crack configuration using the <code class="docutils literal notranslate"><span class="pre">nn</span></code> and <code class="docutils literal notranslate"><span class="pre">changed_nn</span></code>
properties and the <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> parameter from the atoms structure, as well as the
selection parameters in <code class="docutils literal notranslate"><span class="pre">params</span></code>. If <code class="docutils literal notranslate"><span class="pre">update_embed</span></code> is true then the embed region is
updated, otherwise we simply recompute the fit region from the embed region.
The value of <code class="docutils literal notranslate"><span class="pre">num_directionality</span></code> returned can be passed to adjustable_potential_init.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_update_selection_coordination</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_make_seed">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_make_seed</code><span class="sig-paren">(</span><em>crack_slab</em>, <em>params</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_make_seed" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_slab</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_make_seed</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_check_coordination">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_check_coordination</code><span class="sig-paren">(</span><em>at</em>, <em>params</em>, <em>j</em><span class="optional">[</span>, <em>y</em>, <em>x_boundaries</em>, <em>neigh_removed</em>, <em>at_for_connectivity</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_check_coordination" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>at</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object</span></dt>
<dd></dd>
<dt><strong>j</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>y</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(float,’d’), optional</span></dt>
<dd></dd>
<dt><strong>x_boundaries</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>neigh_removed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-1 array(‘i’) with bounds (qp_n0), optional</span></dt>
<dd></dd>
<dt><strong>at_for_connectivity</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_check_coordination</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_print">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_print</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.crack.crack_print" title="Permalink to this definition">¶</a></dt>
<dd><p>Print crack slab to XYZ file, using properties defined in ‘params%io_print_properties’
or all properties if ‘params%io_print_all_properties’ is true.</p>
<p>Routine is wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">crack_print</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descclassname">quippy.crack.</code><code class="descname">crack_print</code><span class="sig-paren">(</span><em>at</em>, <em>cio</em>, <em>params</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>at</strong> (<a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object) – </li>
<li><strong>cio</strong> (<a class="reference internal" href="io.html#quippy.cinoutput.CInOutput" title="quippy.cinoutput.CInOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">CInOutput</span></code></a> object) – </li>
<li><strong>params</strong> (<a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_print_cio</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.crack.</code><code class="descname">crack_print</code><span class="sig-paren">(</span><em>at</em>, <em>filename</em>, <em>params</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>at</strong> (<a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object) – </li>
<li><strong>filename</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>params</strong> (<a class="reference internal" href="#quippy.crack.CrackParams" title="quippy.crack.CrackParams"><code class="xref py py-class docutils literal notranslate"><span class="pre">CrackParams</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">crack_print_filename</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/Utils/cracktools.f95">src/Utils/cracktools.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_strain_energy_release_rate">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_strain_energy_release_rate</code><span class="sig-paren">(</span><em>at</em>, <em>bulk=None</em>, <em>f_min=0.8</em>, <em>f_max=0.9</em>, <em>stem=None</em>, <em>avg_pos=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#crack_strain_energy_release_rate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.crack_strain_energy_release_rate" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute strain energy release rate G from elastic potential energy in a strip</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_strain">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_strain</code><span class="sig-paren">(</span><em>at</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#crack_strain"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.crack_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns strain of crack specimen</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.crack_find_griffith_load">
<code class="descclassname">quippy.crack.</code><code class="descname">crack_find_griffith_load</code><span class="sig-paren">(</span><em>a</em>, <em>b</em>, <em>pot</em>, <em>relax=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#crack_find_griffith_load"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.crack_find_griffith_load" title="Permalink to this definition">¶</a></dt>
<dd><p>Given two configurations (a, b) which differ by one broken bond,
find the Griffith load, that is the load at which <cite>a</cite> and <cite>b</cite> have
the same energy accorinding to the model potential <cite>pot</cite>.</p>
<p>Returns (strain, G, a_rescaled, b_rescaled).</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.stress_intensity_factor">
<code class="descclassname">quippy.crack.</code><code class="descname">stress_intensity_factor</code><span class="sig-paren">(</span><em>at</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#stress_intensity_factor"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.stress_intensity_factor" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns stress instensity factor for mode I loading (K_I) in MPa sqrt(m)</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.make_crack_advance_map">
<code class="descclassname">quippy.crack.</code><code class="descname">make_crack_advance_map</code><span class="sig-paren">(</span><em>atoms</em>, <em>tol=0.001</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#make_crack_advance_map"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.make_crack_advance_map" title="Permalink to this definition">¶</a></dt>
<dd><p>Find mapping from atom indices to the index of atom one step ahead
of them in the crack propagation direction (i.e. along +x).</p>
<p>Requires ‘LatticeConstant’, ‘CleavagePlane’, and ‘CrackFront’ to
be available in atoms.info dictionary.</p>
<p>Returns integer array of shape (len(atoms),), and also adds a new
array ‘advance_map’ into the Atoms object.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.find_crack_tip_coordination">
<code class="descclassname">quippy.crack.</code><code class="descname">find_crack_tip_coordination</code><span class="sig-paren">(</span><em>atoms</em>, <em>edge_tol=10.0</em>, <em>strip_height=30.0</em>, <em>nneightol=1.3</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#find_crack_tip_coordination"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.find_crack_tip_coordination" title="Permalink to this definition">¶</a></dt>
<dd><p>Return position of crack tip in <cite>atoms</cite>, based on atomic coordination.</p>
<p>If <cite>atoms</cite> does not contain an <cite>advance_map</cite> property, then
<a class="reference internal" href="#quippy.crack.make_crack_advance_map" title="quippy.crack.make_crack_advance_map"><code class="xref py py-func docutils literal notranslate"><span class="pre">make_crack_advance_map()</span></code></a> is called to generate the map.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>atoms</strong> <span class="classifier-delimiter">:</span> <span class="classifier">:class:<a href="#id3"><span class="problematic" id="id4">`</span></a>~.Atoms’ object</span></dt>
<dd><p class="first last">The Atoms object containing the crack slab.</p>
</dd>
<dt><strong>edge_tol</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Distance from edge of system within which to exclude
undercoodinated atoms.</p>
</dd>
<dt><strong>strip_height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Height of strip along centre of slab in which to look
for the track.</p>
</dd>
<dt><strong>nneightol</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Nearest neighbour tolerance, as a fraction of sum of
covalent radii of atomic species.</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>crack_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array</span></dt>
<dd><p class="first last">x, y, and z coordinates of the crack tip. Also set in <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code>
in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code> dictionary.</p>
</dd>
<dt><strong>tip_atoms</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array</span></dt>
<dd><p class="first last">Indices of atoms near the tip Also set in <code class="docutils literal notranslate"><span class="pre">crack_tip</span></code> property.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.irwin_modeI_crack_tip_stress_field">
<code class="descclassname">quippy.crack.</code><code class="descname">irwin_modeI_crack_tip_stress_field</code><span class="sig-paren">(</span><em>K</em>, <em>r</em>, <em>t</em>, <em>xy_only=True</em>, <em>nu=0.5</em>, <em>stress_state='plane strain'</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#irwin_modeI_crack_tip_stress_field"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.irwin_modeI_crack_tip_stress_field" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute Irwin singular crack tip stress field</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>K</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Mode I stress intensity factor. Units should match units of <cite>r</cite>.</p>
</dd>
<dt><strong>r</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array_like</span></dt>
<dd><p class="first last">Radial distances from crack tip. Can be a multidimensional
array to evaluate stress field on a grid.</p>
</dd>
<dt><strong>t</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array_like</span></dt>
<dd><p class="first last">Angles from horzontal line y=0 ahead of crack tip,
measured anticlockwise. Should have same shape as <cite>r</cite>.</p>
</dd>
<dt><strong>xy_only</strong> <span class="classifier-delimiter">:</span> <span class="classifier">bool</span></dt>
<dd><p class="first last">If True (default) only xx, yy, xy and yx components will be set.</p>
</dd>
<dt><strong>nu</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Poisson ratio. Used only when <code class="docutils literal notranslate"><span class="pre">xy_only=False</span></code>, to determine zz stresses</p>
</dd>
<dt><strong>stress_state</strong> <span class="classifier-delimiter">:</span> <span class="classifier">str</span></dt>
<dd><p class="first last">One of”plane stress” or “plane strain”. Used if xyz_only=False to
determine zz stresses.</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>sigma</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array with shape <code class="docutils literal notranslate"><span class="pre">r.shape</span> <span class="pre">+</span> <span class="pre">(3,3)</span></code></span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.strain_to_G">
<code class="descclassname">quippy.crack.</code><code class="descname">strain_to_G</code><span class="sig-paren">(</span><em>strain</em>, <em>E</em>, <em>nu</em>, <em>orig_height</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#strain_to_G"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.strain_to_G" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert from strain to energy release rate G for thin strip geometry</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>strain</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Dimensionless ratio <code class="docutils literal notranslate"><span class="pre">(current_height</span> <span class="pre">-</span> <span class="pre">orig_height)/orig_height</span></code></p>
</dd>
<dt><strong>E</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Young’s modulus relevant for a pull in y direction sigma_yy/eps_yy</p>
</dd>
<dt><strong>nu</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Poission ratio -eps_yy/eps_xx</p>
</dd>
<dt><strong>orig_height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Unstrained height of slab</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>G</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Energy release rate in units consistent with input
(i.e. in eV/A**2 if eV/A/fs units used)</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.G_to_strain">
<code class="descclassname">quippy.crack.</code><code class="descname">G_to_strain</code><span class="sig-paren">(</span><em>G</em>, <em>E</em>, <em>nu</em>, <em>orig_height</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#G_to_strain"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.G_to_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert from energy release rate G to strain for thin strip geometry</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>G</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Energy release rate in units consistent with <cite>E</cite> and <cite>orig_height</cite></p>
</dd>
<dt><strong>E</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Young’s modulus relevant for a pull in y direction sigma_yy/eps_yy</p>
</dd>
<dt><strong>nu</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Poission ratio -eps_yy/eps_xx</p>
</dd>
<dt><strong>orig_height</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Unstrained height of slab</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>strain</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Dimensionless ratio <code class="docutils literal notranslate"><span class="pre">(current_height</span> <span class="pre">-</span> <span class="pre">orig_height)/orig_height</span></code></p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.get_strain">
<code class="descclassname">quippy.crack.</code><code class="descname">get_strain</code><span class="sig-paren">(</span><em>atoms</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#get_strain"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.get_strain" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the current strain on thin strip configuration <cite>atoms</cite></p>
<p>Requires unstrained height of slab to be stored as <code class="docutils literal notranslate"><span class="pre">OrigHeight</span></code>
key in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code> dictionary.</p>
<p>Also updates value stored in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.get_energy_release_rate">
<code class="descclassname">quippy.crack.</code><code class="descname">get_energy_release_rate</code><span class="sig-paren">(</span><em>atoms</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#get_energy_release_rate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.get_energy_release_rate" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the current energy release rate G for <a href="#id5"><span class="problematic" id="id6">`</span></a>atoms</p>
<p>Also updates value stored in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code> dictionary.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.get_stress_intensity_factor">
<code class="descclassname">quippy.crack.</code><code class="descname">get_stress_intensity_factor</code><span class="sig-paren">(</span><em>atoms</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#get_stress_intensity_factor"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.get_stress_intensity_factor" title="Permalink to this definition">¶</a></dt>
<dd><p>Return stress intensity factor K_I</p>
<p>Also updates value stored in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code> dictionary.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.fit_crack_stress_field">
<code class="descclassname">quippy.crack.</code><code class="descname">fit_crack_stress_field</code><span class="sig-paren">(</span><em>atoms</em>, <em>r_range=(0.0</em>, <em>50.0)</em>, <em>initial_params=None</em>, <em>fix_params=None</em>, <em>sigma=None</em>, <em>avg_sigma=None</em>, <em>avg_decay=0.005</em>, <em>calc=None</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#fit_crack_stress_field"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.fit_crack_stress_field" title="Permalink to this definition">¶</a></dt>
<dd><p>Perform a least squares fit of near-tip stress field to Irwin solution</p>
<p>Stresses on the atoms are fit to the Irwin K-field singular crack tip
solution, allowingthe crack position, stress intensity factor and
far-field stress components to vary during the fit.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>atoms</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="atoms.html#quippy.atoms.Atoms" title="quippy.atoms.Atoms"><code class="xref py py-class docutils literal notranslate"><span class="pre">Atoms</span></code></a> object</span></dt>
<dd><p class="first">Crack system. For the initial fit, the following keys are used
from the <code class="xref py py-attr docutils literal notranslate"><span class="pre">info</span></code> dictionary:</p>
<blockquote>
<div><ul class="simple">
<li><code class="docutils literal notranslate"><span class="pre">YoungsModulus</span></code></li>
<li><code class="docutils literal notranslate"><span class="pre">PossionRatio_yx</span></code></li>
<li><code class="docutils literal notranslate"><span class="pre">G</span></code> — current energy release rate</li>
<li><code class="docutils literal notranslate"><span class="pre">strain</span></code> — current applied strain</li>
<li><code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> — initial guess for crack tip position</li>
</ul>
</div></blockquote>
<p>The initial guesses for the stress intensity factor <code class="docutils literal notranslate"><span class="pre">K</span></code> are
far-field stress <code class="docutils literal notranslate"><span class="pre">sigma0</span></code> are computed from
<code class="docutils literal notranslate"><span class="pre">YoungsModulus</span></code>, <code class="docutils literal notranslate"><span class="pre">PoissonRatio_yx</span></code>, <code class="docutils literal notranslate"><span class="pre">G</span></code> and <code class="docutils literal notranslate"><span class="pre">strain</span></code>,
assuming plane strain in thin strip boundary conditions.</p>
<p class="last">On exit, new <code class="docutils literal notranslate"><span class="pre">K</span></code>, <code class="docutils literal notranslate"><span class="pre">sigma0</span></code> and <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> entries are set
in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">info</span></code> dictionary. These values are then
used as starting guesses for subsequent fits.</p>
</dd>
<dt><strong>r_range</strong> <span class="classifier-delimiter">:</span> <span class="classifier">sequence of two floats, optional</span></dt>
<dd><p class="first last">If present, restrict the stress fit to an annular region
<code class="docutils literal notranslate"><span class="pre">r_range[0]</span> <span class="pre">&lt;=</span> <span class="pre">r</span> <span class="pre">&lt;</span> <span class="pre">r_range[1]</span></code>, centred on the previous crack
position (from the <code class="docutils literal notranslate"><span class="pre">CrackPos</span></code> entry in <code class="docutils literal notranslate"><span class="pre">atoms.info</span></code>). If
r_range is <code class="docutils literal notranslate"><span class="pre">None</span></code>, fit is carried out for all atoms.</p>
</dd>
<dt><strong>initial_params</strong> <span class="classifier-delimiter">:</span> <span class="classifier">dict</span></dt>
<dd><p class="first last">Names and initial values of parameters. Missing initial values
are guessed from Atoms object.</p>
</dd>
<dt><strong>fix_params</strong> <span class="classifier-delimiter">:</span> <span class="classifier">dict</span></dt>
<dd><p class="first last">Names and values of parameters to fix during the fit,
e.g. <code class="docutils literal notranslate"><span class="pre">{y0:</span> <span class="pre">0.0}</span></code> to constrain the fit to the line y=0</p>
</dd>
<dt><strong>sigma</strong> <span class="classifier-delimiter">:</span> <span class="classifier">None or array with shape (len(atoms), 3, 3)</span></dt>
<dd><p class="first last">Explicitly provide the per-atom stresses. Avoids calling Atoms’
calculators <a class="reference internal" href="potential.html#quippy.potential.Potential.get_stresses" title="quippy.potential.Potential.get_stresses"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_stresses()</span></code></a> method.</p>
</dd>
<dt><strong>avg_sigma</strong> <span class="classifier-delimiter">:</span> <span class="classifier">None or array with shape (len(atoms), 3, 3)</span></dt>
<dd><p class="first last">If present, use this array to accumulate the time-averaged
stress field. Useful when processing a trajectory.</p>
</dd>
<dt><strong>avg_decay</strong> <span class="classifier-delimiter">:</span> <span class="classifier">real</span></dt>
<dd><p class="first last">Factor by which average stress is attenuated at each step.
Should be set to <code class="docutils literal notranslate"><span class="pre">dt/tau</span></code> where <code class="docutils literal notranslate"><span class="pre">dt</span></code> is MD time-step
and <code class="docutils literal notranslate"><span class="pre">tau</span></code> is a characteristic averaging time.</p>
</dd>
<dt><strong>calc</strong> <span class="classifier-delimiter">:</span> <span class="classifier">Calculator object, optional</span></dt>
<dd><p class="first">If present, override the calculator used to compute stresses
on the atoms. Default is <code class="docutils literal notranslate"><span class="pre">atoms.get_calculator</span></code>.</p>
<p class="last">To use the atom resolved stress tensor pass an instance of the
<a class="reference internal" href="elasticity.html#quippy.elasticity.AtomResolvedStressField" title="quippy.elasticity.AtomResolvedStressField"><code class="xref py py-class docutils literal notranslate"><span class="pre">AtomResolvedStressField</span></code></a> class.</p>
</dd>
<dt><strong>verbose</strong> <span class="classifier-delimiter">:</span> <span class="classifier">bool, optional</span></dt>
<dd><p class="first last">If set to True, print additional information about the fit.</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>params</strong> <span class="classifier-delimiter">:</span> <span class="classifier">dict with keys <code class="docutils literal notranslate"><span class="pre">[K,</span> <span class="pre">x0,</span> <span class="pre">y0,</span> <span class="pre">sxx0,</span> <span class="pre">syy0,</span> <span class="pre">sxy0]</span></code></span></dt>
<dd><p class="first last">Fitted parameters, in a form suitable for passin
<code class="xref py py-class docutils literal notranslate"><span class="pre">IrwinStressField</span></code> constructor. These are the stress intensity
factor <cite>K</cite>, the centre of the stress field <code class="docutils literal notranslate"><span class="pre">(x0,</span> <span class="pre">y0)</span></code>, and the
far field contribution to the stress <code class="docutils literal notranslate"><span class="pre">(sxx0,</span> <span class="pre">syy0,</span> <span class="pre">sxy0)</span></code>.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.find_crack_tip_stress_field">
<code class="descclassname">quippy.crack.</code><code class="descname">find_crack_tip_stress_field</code><span class="sig-paren">(</span><em>atoms</em>, <em>r_range=None</em>, <em>initial_params=None</em>, <em>fix_params=None</em>, <em>sigma=None</em>, <em>avg_sigma=None</em>, <em>avg_decay=0.005</em>, <em>calc=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#find_crack_tip_stress_field"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.find_crack_tip_stress_field" title="Permalink to this definition">¶</a></dt>
<dd><p>Find the position of the crack tip by fitting to the Irwin <cite>K</cite>-field solution</p>
<p>Fit is carried out using <a class="reference internal" href="#quippy.crack.fit_crack_stress_field" title="quippy.crack.fit_crack_stress_field"><code class="xref py py-func docutils literal notranslate"><span class="pre">fit_crack_stress_field()</span></code></a>, and parameters
have the same meaning as there.</p>
<div class="admonition seealso">
<p class="first admonition-title">See also</p>
<p class="last"><a class="reference internal" href="#quippy.crack.fit_crack_stress_field" title="quippy.crack.fit_crack_stress_field"><code class="xref py py-obj docutils literal notranslate"><span class="pre">fit_crack_stress_field</span></code></a></p>
</div>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.plot_stress_fields">
<code class="descclassname">quippy.crack.</code><code class="descname">plot_stress_fields</code><span class="sig-paren">(</span><em>atoms</em>, <em>r_range=None</em>, <em>initial_params=None</em>, <em>fix_params=None</em>, <em>sigma=None</em>, <em>avg_sigma=None</em>, <em>avg_decay=0.005</em>, <em>calc=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#plot_stress_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.plot_stress_fields" title="Permalink to this definition">¶</a></dt>
<dd><p>Fit and plot atomistic and continuum stress fields</p>
<p>Firstly a fit to the Irwin <cite>K</cite>-field solution is carried out using
<a class="reference internal" href="#quippy.crack.fit_crack_stress_field" title="quippy.crack.fit_crack_stress_field"><code class="xref py py-func docutils literal notranslate"><span class="pre">fit_crack_stress_field()</span></code></a>, and parameters have the same
meaning as for that function. Then plots of the
<span class="math notranslate nohighlight">\(\sigma_{xx}\)</span>, <span class="math notranslate nohighlight">\(\sigma_{yy}\)</span>, <span class="math notranslate nohighlight">\(\sigma_{xy}\)</span>
fields are produced for atomistic and continuum cases, and for the
residual error after fitting.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.thin_strip_displacement_y">
<code class="descclassname">quippy.crack.</code><code class="descname">thin_strip_displacement_y</code><span class="sig-paren">(</span><em>x</em>, <em>y</em>, <em>strain</em>, <em>a</em>, <em>b</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#thin_strip_displacement_y"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.thin_strip_displacement_y" title="Permalink to this definition">¶</a></dt>
<dd><p>Return vertical displacement ramp used to apply initial strain to slab</p>
<p>Strain is increased from 0 to strain over distance <span class="math notranslate nohighlight">\(a &lt;= x &lt;= b\)</span>.
Region <span class="math notranslate nohighlight">\(x &lt; a\)</span> is rigidly shifted up/down by <code class="docutils literal notranslate"><span class="pre">strain*height/2</span></code>.</p>
<p>Here is an example of how to use this function on an artificial
2D square atomic lattice. The positions are plotted before (left)
and after (right) applying the displacement, and the horizontal and
vertical lines show the <cite>strain</cite> (red), <cite>a</cite> (green) and <cite>b</cite> (blue)
parameters.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="n">w</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">h</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">strain</span> <span class="o">=</span> <span class="mf">0.1</span><span class="p">;</span> <span class="n">a</span> <span class="o">=</span> <span class="o">-</span><span class="mf">0.5</span><span class="p">;</span> <span class="n">b</span> <span class="o">=</span>  <span class="mf">0.0</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="n">w</span><span class="p">,</span> <span class="n">w</span><span class="p">,</span> <span class="mi">20</span><span class="p">)</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="n">h</span><span class="p">,</span> <span class="n">h</span><span class="p">,</span> <span class="mi">20</span><span class="p">)</span>
<span class="n">X</span><span class="p">,</span> <span class="n">Y</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">meshgrid</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="n">u_y</span> <span class="o">=</span> <span class="n">thin_strip_displacement_y</span><span class="p">(</span><span class="n">X</span><span class="p">,</span> <span class="n">Y</span><span class="p">,</span> <span class="n">strain</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>

<span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">disp</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="n">u_y</span><span class="p">]):</span>
    <span class="n">plt</span><span class="o">.</span><span class="n">subplot</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">plt</span><span class="o">.</span><span class="n">scatter</span><span class="p">(</span><span class="n">X</span><span class="p">,</span> <span class="n">Y</span> <span class="o">+</span> <span class="n">disp</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="s1">&#39;k&#39;</span><span class="p">,</span> <span class="n">s</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">y</span> <span class="ow">in</span> <span class="p">[</span><span class="o">-</span><span class="n">h</span><span class="p">,</span> <span class="n">h</span><span class="p">]:</span>
        <span class="n">plt</span><span class="o">.</span><span class="n">axhline</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">color</span><span class="o">=</span><span class="s1">&#39;r&#39;</span><span class="p">,</span> <span class="n">linewidth</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">linestyle</span><span class="o">=</span><span class="s1">&#39;dashed&#39;</span><span class="p">)</span>
        <span class="n">plt</span><span class="o">.</span><span class="n">axhline</span><span class="p">(</span><span class="n">y</span><span class="o">*</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">strain</span><span class="p">),</span> <span class="n">color</span><span class="o">=</span><span class="s1">&#39;r&#39;</span><span class="p">,</span> <span class="n">linewidth</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">x</span><span class="p">,</span> <span class="n">c</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">([</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;g&#39;</span><span class="p">,</span> <span class="s1">&#39;b&#39;</span><span class="p">]):</span>
        <span class="n">plt</span><span class="o">.</span><span class="n">axvline</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">color</span><span class="o">=</span><span class="n">c</span><span class="p">,</span> <span class="n">linewidth</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
<a class="reference internal image-reference" href="_images/thin-strip-displacement-y.png"><img alt="_images/thin-strip-displacement-y.png" class="align-center" src="_images/thin-strip-displacement-y.png" style="width: 600px;" /></a>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>x</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array</span></dt>
<dd></dd>
<dt><strong>y</strong> <span class="classifier-delimiter">:</span> <span class="classifier">array</span></dt>
<dd><p class="first last">Atomic positions in unstrained slab, centered on origin x=0,y=0</p>
</dd>
<dt><strong>strain</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">Far field strain to apply</p>
</dd>
<dt><strong>a</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">x coordinate for beginning of strain ramp</p>
</dd>
<dt><strong>b</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd><p class="first last">x coordinate for end of strain ramp</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="quippy.crack.print_crack_system">
<code class="descclassname">quippy.crack.</code><code class="descname">print_crack_system</code><span class="sig-paren">(</span><em>crack_direction</em>, <em>cleavage_plane</em>, <em>crack_front</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/crack.html#print_crack_system"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.crack.print_crack_system" title="Permalink to this definition">¶</a></dt>
<dd><p>Pretty printing of crack crystallographic coordinate system</p>
<p>Specified by Miller indices for crack_direction (x),
cleavage_plane (y) and crack_front (z), each of which should be
a sequence of three floats</p>
</dd></dl>

</div>


           </div>
           
          </div>
          <footer>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2008-2016, James Kermode

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script>

  
  
    
   

</body>
</html>